home / skills / coowoolf / insighthunt-skills / nlx-design-stack

nlx-design-stack skill

safe

This skill designs natural language interfaces by applying a structured NLX stack to create transparent prompts, plans, processes, and follow-ups that users

npx playbooks add skill coowoolf/insighthunt-skills --skill nlx-design-stack

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

3.3 KB

---
name: nlx-design-stack
description: Use when designing AI agents or chatbots, when raw model outputs feel like a black box, or when building natural language interfaces that need structure and trust
---

# NLX (Natural Language Experience) Design Stack

## Overview

A framework defining the new principles and UI constructs required for **Natural Language Interfaces**. Moves beyond simple chat to structured, designed conversations.

**Core principle:** NLX is the new UX. Conversations have grammars, structures, and invisible UI elements.

## The Four Elements

```
┌─────────────────────────────────────────────────────────────────┐
│                      NLX DESIGN STACK                           │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   ┌──────────────┐   ┌──────────────┐                           │
│   │   PROMPTS    │   │    PLANS     │                           │
│   │              │   │              │                           │
│   │  New UI      │   │  Structured  │                           │
│   │  Construct   │   │  Editable    │                           │
│   │  (Input)     │   │  Outputs     │                           │
│   └──────────────┘   └──────────────┘                           │
│                                                                  │
│   ┌──────────────┐   ┌──────────────┐                           │
│   │   PROCESS    │   │  FOLLOW-UPS  │                           │
│   │              │   │              │                           │
│   │  Show the    │   │  Guided      │                           │
│   │  Work /      │   │  Navigation  │                           │
│   │  Thinking    │   │  Suggestions │                           │
│   └──────────────┘   └──────────────┘                           │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘
```

## Key Principles

| Element | Principle |
|---------|-----------|
| **Prompts** | Treat prompts as distinct UI elements (like dropdowns) |
| **Plans** | Return structured, editable plans for complex goals |
| **Process** | Visualize reasoning to build trust ("thinking aloud") |
| **Follow-ups** | Proactively suggest next steps ("happy path" guidance) |

## Common Mistakes

- Assuming "the model is the product" (neglecting design)
- Making the AI a black box without feedback
- Failing to guide users after an output

---

*Source: Aparna Chennapragada (Microsoft CPO) via Lenny's Podcast*

Overview

This skill teaches the NLX (Natural Language Experience) design stack for building structured, trustworthy AI-driven conversations. It frames prompts, plans, process, and follow-ups as explicit UI constructs to move beyond free-form chat. The goal is to make model behavior visible, editable, and actionable for end users.

How this skill works

The skill inspects conversational designs and maps outputs to four elements: Prompts (treating inputs as UI controls), Plans (structured editable outputs), Process (visible reasoning or progress), and Follow-ups (guided next steps). It highlights gaps where the model is treated as a black box and recommends concrete interface patterns to surface structure and control. It produces targeted suggestions for redesigning prompts, exposing intermediate steps, and adding proactive navigation options.

When to use it

Designing or refining AI agents, chatbots, or virtual assistants
When raw model outputs feel opaque or unpredictable
Building natural language interfaces that require structure, validation, or multi-step goals
Creating product experiences where user trust and clarity matter
Planning workflows that need editable or repeatable plans

Best practices

Treat prompts as explicit UI elements (e.g., dropdowns, templates) rather than free text only
Return structured, editable plans for multi-step tasks so users can inspect and modify results
Surface process information or partial results to build trust rather than hiding reasoning
Include follow-up suggestions and a clear “happy path” to guide next actions
Avoid delivering final answers without verification steps or ways to correct them

Example use cases

A customer support bot that shows an editable troubleshooting plan and lets users skip or reorder steps
A content assistant that returns a structured outline and allows inline edits before final generation
A business workflow agent that visualizes task progress and exposes intermediate data for approval
A scheduling assistant that uses prompt controls to constrain inputs and offers next-step suggestions
A form-filling agent that previews extracted fields and asks guided follow-ups for missing or unclear values

FAQ

How does NLX differ from conventional chat UI design?

NLX treats conversational pieces as interface constructs (prompts, plans, process, follow-ups) rather than free-form messages. It emphasizes structure, editability, and visible work.

Will exposing process hurt model performance or privacy?

Exposing process focuses on surface-level reasoning, progress, or intermediate outputs that improve clarity. Sensitive details should still be filtered; design chooses which internal steps to show.