iblameandrew/local-deepthink/qdad

/qdad — Qualitative Diffusion App Designer

Use Qualitative Diffusion (QDAD) when you need to turn a vague aesthetic or product vibe into a concrete, buildable app specification — the same job Midjourney does for images, but the latent is language and the decode target is an agentic coding prompt.

This skill is portable. You do not need the open-deepthink HTTP server. Same algorithm as App Slot Machine Mode (deepthink/qdad/).

How to execute (build the script on the fly — mandatory)

Do not point the user at a pre-installed CLI path. You write the runner into the workspace, then run it with parsed parameters.

Protocol (every /qdad invoke)

1. Parse the user message → Midjourney-style prompt + optional

N=…, steps=…, temperature flags, or --debug.

1. Materialize the runner:

• Create .skill-runs/ in the workspace root if missing.
• Read skill sibling run_template.py (next to this SKILL.md). If missing,

write Appendix A from the end of this skill.

• Write source to `.skill-runs/run_qdad.py` (overwrite).

1. Execute:

python .skill-runs/run_qdad.py \
  --prompt "<Midjourney-style app intent>" \
  --n 3 \
  --temperature-scale 1.3 \
  --denoising-steps 2 \
  --noun-verb-temperature 0.6 \
  --out .skill-runs/qdad-result.json

Debug / no API cost:

python .skill-runs/run_qdad.py --prompt "<intent>" --debug --n 2 --denoising-steps 1

1. Deliver stdout (# App Build Prompt) as the primary answer.
2. Handoff — only implement the app after the user approves.

The script auto-discovers deepthink (walk parents / OPEN_DEEPTHINK_ROOT). Engine: deepthink.qdad.run_qdad_pipeline (foundation → grid → noise → denoise → synth).

CLI parameters

If you cannot write/run Python, fall back to the manual QDAD procedure below. Prefer materializing and running the script.

Technique analysis (read this; it is the algorithm)

What classical diffusion does

1. Start from noise in a continuous latent.
2. Iteratively denoise toward the data manifold (score matching / reverse SDE).
3. Decode to pixels (or tokens).

What Qualitative Diffusion does

Why this is not “just brainstorm features”

1. Basis structure — Features are not free-floating ideas. Each sits at a

forced intersection noun_i × verb_j. That is the qualitative analogue of a tensor product / coordinate system: diversity is systematic, not random.

1. Forward then reverse — Noise induction explores; critics project back

toward intent + implementability. One-shot ideation skips the reverse process.

1. Signature-locked critics — Critic (i,j) shares the exact signature of

FeatureAgent (i,j). Denoising cannot “edit away” the basis; it cleans along that direction (score matching in one local chart of feature space).

1. Temperature as σ — GUI/params map: high Temperature Scale ≈ more

qualitative noise; more Denoising Steps ≈ longer reverse chain.

1. Decode is separate — Synthesis is not “pick the best cell.” It *merges,

prioritizes, and architectures* the clean matrix into one shippable brief.

Philosophy (strict — do not dilute)

• Language is the computational medium (not numbers, not embeddings you

manipulate by hand).

• Nouns and verbs act as orthogonal basis directions.
• High temperature = controlled qualitative noise.
• Critic agents = qualitative reverse diffusion / score matching.
• The whole process turns a vague aesthetic prompt into a concrete, buildable

app specification the same way Midjourney turns a vague prompt into an image.

When to invoke (and when not)

Invoke when:

• User has a vibe / Midjourney-style app idea (“cozy night writing app…”)
• You need a full app build brief, not a single function
• Product surface is under-specified (features, UX, NFRs all fuzzy)
• User says /qdad, “diffuse this”, “slot machine”, “turn this into a build prompt”

Do not invoke when:

• Task is a local bugfix or a single clear feature already specified
• User asked for an immediate small code edit only
• /qnn is more appropriate (stuck debug strategy map, not app design)

If the user invokes /qdad explicitly, always run the full procedure.

Usage

/qdad [Midjourney-style app intent]

Examples:

• /qdad a cozy productivity app for writers who work at night, soft dark mode, gentle notifications, offline-first
• /qdad N=3 steps=2 — minimal habit tracker that feels like a garden
• /qdad expand this into a full build prompt: marketplace for local makers
• /qdad (uses the last vague product idea in the conversation)

Parameters (optional; parse from user text or defaults)

Budget: agents per noise/denoise round = N². Total heavy LLM calls ≈ 1 (foundation) + N² (noise) + Steps×N² (critics) + 1 (synth). Prefer N=3, steps=2 when cost-sensitive; N=4–5, steps=3 for rich apps.

Announce params before running:

QDAD: N×N grid, noise_T=…, steps=…, noun_verb_T=…
Philosophy: language=medium; nouns×verbs=basis; high-T=noise; critics=reverse diffusion

Step 0 — Capture the Intent Brief

Write a short brief (do not solve the product yet):

If attachments/repo context exist, note paths that should ground features. Present the brief compactly, then proceed unless the user corrects it.

Step 1 — Phase 0: Foundation (qualitative basis)

Generate exactly N distinct nouns and exactly N distinct verbs.

Basis rules

• Nouns = object / substance / place / affordance axes (rows)
• Verbs = action / process / transformation axes (columns)
• Concrete enough to ground features; mutually distinct; span the *aesthetic

space* of the intent (not just synonyms of “app” / “user”)

• Prefer evocative, implementable words over pure abstractions

Prompt skeleton (foundation)

You are the QDAD Foundation Generator.
 
QUALITATIVE COMPUTATION CONTRACT
- Language is the computational medium (not numbers).
- Nouns and verbs are orthogonal basis directions of feature space.
- A feature is a language-vector at the intersection of one noun and one verb.
 
User prompt:
---
{user_prompt}
---
 
Generate exactly {N} distinct nouns and {N} distinct verbs.
Output ONLY JSON: {"nouns":[...], "verbs":[...]}

Use noun_verb_temperature if the host supports temperature; otherwise ask for slightly more diverse / surprising basis words when N is small.

Log: nouns = […], verbs = […].

Hard fail: fewer than N unique items, or all generic (“data”, “manage”, “system”).

Step 2 — Phase 1: Agent grid construction

For each i in 0..N-1, j in 0..N-1:

FeatureAgent_{i}_{j}
  noun = nouns[i]
  verb = verbs[j]
  signature = noun × verb

Permanent assignment. No reassignment later. Log a compact grid:

        verb0    verb1    …
noun0   A00      A01
noun1   A10      A11
…

Step 3 — Phase 2: Noise induction (forward diffusion)

In parallel (or sequential if no sub-agents), for every cell (i,j):

FeatureAgent system prompt

You are FeatureAgent_{i}_{j}.
Your unique qualitative signature is noun "{noun}" × verb "{verb}".
Your sole purpose is to invent exactly ONE concrete, implementable feature
for an application. The feature must feel like a natural expression of the
interaction between "{noun}" and "{verb}" given the user intent.
 
User intent:
---
{user_prompt}
---
 
FORWARD DIFFUSION: Invent one wild, imperfect, slightly hallucinated but still
related feature. Embrace controlled qualitative noise. Rough edges and odd
metaphors are allowed — they are the language analogue of Gaussian noise.
Stay in orbit of the intent.
 
Output ONLY the feature (2–6 sentences). No JSON. No headings.

Use noise temperature (Temperature Scale) for these calls.

Collect noisy_features[i][j].

Do not polish yet. Noise is a feature of the algorithm.

Step 4 — Phase 3: Iterative qualitative denoising

For step = 1 .. Denoising_Steps:

In parallel, for every cell (i,j), spawn CriticAgent_{i}_{j} with the exact same noun+verb signature:

You are CriticAgent_{i}_{j}.
You share signature noun "{noun}" + verb "{verb}".
You are the inverse of noise induction: qualitative reverse diffusion / score matching.
Clean imperfections, remove contradictions, sharpen original intent, make the
feature coherent, useful, and implementable — while remaining a true expression
of "{noun}" + "{verb}".
 
User intent:
---
{user_prompt}
---
 
Denoising step: {step} of {total_steps}
(Early steps: gross noise. Late steps: fidelity to intent.)
 
Current feature:
---
{current_feature}
---
 
Output ONLY the refined feature (2–6 sentences).

Use a cooler temperature than noise (≈ 0.5 × noise_T, clamped to ~0.3–1.0).

Replace features[i][j] with the critic output after each full parallel round.

Optional: keep snapshots step_1, step_2, … for transparency.

After the final step: clean_features = features.

Step 5 — Phase 4: Synthesis (decode)

One Synthesizer agent receives:

• Original user prompt
• Nouns, verbs
• Full clean N×N matrix (each cell labeled with noun×verb)

Required output format (exact)

# App Build Prompt
 
## High-Level Vision
[1-2 sentence summary]
 
## Core Features (synthesized & prioritized from the diffusion matrix)
1....
2....
...
 
## Technical Architecture Suggestions
-...
 
## UI/UX Direction
-...
 
## Non-Functional Requirements
-...
 
## Implementation Notes for the Coding Agent
-Build this as a complete, runnable application.
-Prefer modern, clean tech (React/Next.js + Tailwind, or Streamlit, or whatever fits best).
-Make it beautiful and immediately usable.

Synthesizer rules