Skip to main content
skill CX Codex

building-ai-chat — Claude Code skill for chat UIs

building-ai-chat guides the design of AI chat interfaces with streamed replies, context controls, and image, file, or voice input. Use it when building an assistant or coding copilot.

MIT 1 installs ★ 533 updated 2025-12-11

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add ancoleman/ai-design-components --skill building-ai-chat -a claude-code
Open on GitHub

What building-ai-chat does

The skill covers interface components for user, AI, and system messages, plus streaming output and rich input. It shows controls for stopping generation, requesting another reply, continuing an answer, and editing a message. Other patterns include feedback buttons, token usage indicators, and scroll behavior.

A minimal React chat uses useChat from ai/react. For streamed Markdown, the examples use Streamdown from @vercel/streamdown; fuller examples are referenced in examples/basic-chat.tsx and the references/ files. The streaming example relies on Streamdown and @vercel/streamdown, so check those dependencies against your project before adopting it.

What it helps with

  • render an answer as it arrives
  • let users stop or regenerate a reply
  • accept image and file attachments in chat
  • show token usage and remaining context
  • collect response feedback and allow message edits

Example prompts for the agent

  • Design a chat that streams Markdown and lets users stop generation.
  • Add image attachments and voice input to this chat interface.
  • Show token usage and controls for rating an AI reply.

How to install building-ai-chat

1Skills CLI (Vercel)

npx skills add ancoleman/ai-design-components --skill building-ai-chat -a claude-code

2Manually: put the files in place

~/.claude/skills/building-ai-chat/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/building-ai-chat/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about building-ai-chat

How do I install building-ai-chat in Claude Code?

Run npx skills add ancoleman/ai-design-components --skill building-ai-chat -a claude-code. The skill file is placed at ~/.claude/skills/building-ai-chat/SKILL.md.

What does building-ai-chat do?

It provides patterns for AI chat interfaces, including streamed messages, reply controls, context indicators, rich input, and feedback.

Which libraries appear in the chat examples?

The minimal React example imports useChat from ai/react. The streaming Markdown example uses Streamdown from @vercel/streamdown.

Source text

SKILL.md · MIT
---
name: building-ai-chat
description: Builds AI chat interfaces and conversational UI with streaming responses, context management, and multi-modal support. Use when creating ChatGPT-style interfaces, AI assistants, code copilots, or conversational agents. Handles streaming text, token limits, regeneration, feedback loops, tool usage visualization, and AI-specific error patterns. Provides battle-tested components from leading AI products with accessibility and performance built in.
---

# AI Chat Interface Components

## Purpose

Define the emerging standards for AI/human conversational interfaces in the 2024-2025 AI integration boom. This skill leverages meta-knowledge from building WITH Claude to establish definitive patterns for streaming UX, context management, and multi-modal interactions. As the industry lacks established patterns, this provides the reference implementation others will follow.

## When to Use

Activate this skill when:
- Building ChatGPT-style conversational interfaces
- Creating AI assistants, copilots, or chatbots
- Implementing streaming text responses with markdown
- Managing conversation context and token limits
- Handling multi-modal inputs (text, images, files, voice)
- Dealing with AI-specific errors (hallucinations, refusals, limits)
- Adding feedback mechanisms (thumbs, regeneration, editing)
- Implementing conversation branching or threading
- Visualizing tool/function calling

## Quick Start

Minimal AI chat interface in under 50 lines:

```tsx
import { useChat } from 'ai/react';

export function MinimalAIChat() {
  const { messages, input, handleInputChange, handleSubmit, isLoading, stop } = useChat();

  return (
    <div className="chat-container">
      <div className="messages">
        {messages.map(m => (
          <div key={m.id} className={`message ${m.role}`}>
            <div className="content">{m.content}</div>
          </div>
        ))}
        {isLoading && <div className="thinking">AI is thinking...</div>}
      </div>

      <form onSubmit={handleSubmit} className="input-form">
        <input
          value={input}
          onChange={handleInputChange}
          placeholder="Ask anything..."
          disabled={isLoading}
        />
        {isLoading ? (
          <button type="button" onClick={stop}>Stop</button>
        ) : (
          <button type="submit">Send</button>
        )}
      </form>
    </div>
  );
}
```

For complete implementation with streaming markdown, see `examples/basic-chat.tsx`.

## Core Components

### Message Display

Build user, AI, and system message bubbles with streaming support:

```tsx
// User message
<div className="message user">
  <div className="content">{message.content}</div>
  <time className="timestamp">{formatTime(message.timestamp)}</time>
</div>

// AI message with streaming
<div className="message ai">
  <Streamdown className="content">{message.content}</Streamdown>
  {message.isStreaming && <span className="cursor">▊</span>}
</div>

// System message
<div className="message system">
  <Icon type="info" />
  <span>{message.content}</span>
</div>
```

For markdown rendering, code blocks, and formatting details, see `references/message-components.md`.

### Input Components

Create rich input experiences with attachments and voice:

```tsx
<div className="input-container">
  <button onClick={attachFile} aria-label="Attach file">
    <PaperclipIcon />
  </button>

  <textarea
    value={input}
    onChange={handleChange}
    onKeyDown={handleKeyDown}
    placeholder="Type a message..."
    rows={1}
    style={{ height: textareaHeight }}
  />

  <button onClick={toggleVoice} aria-label="Voice input">
    <MicIcon />
  </button>

  <button type="submit" disabled={!input.trim() || isLoading}>
    <SendIcon />
  </button>
</div>
```

### Response Controls

Essential controls for AI responses:

```tsx
<div className="response-controls">
  {isStreaming && (
    <button onClick={stop} className="stop-btn">
      Stop generating
    </button>
  )}

  {!isStreaming && (
    <>
      <button onClick={regenerate} aria-label="Regenerate response">
        <RefreshIcon /> Regenerate
      </button>
      <button onClick={continueGeneration} aria-label="Continue">
        Continue
      </button>
      <button onClick={editMessage} aria-label="Edit message">
        <EditIcon /> Edit
      </button>
    </>
  )}
</div>
```

### Feedback Mechanisms

Collect user feedback to improve AI responses:

```tsx
<div className="feedback-controls">
  <button
    onClick={() => sendFeedback('positive')}
    aria-label="Good response"
    className={feedback === 'positive' ? 'selected' : ''}
  >
    <ThumbsUpIcon />
  </button>

  <button
    onClick={() => sendFeedback('negative')}
    aria-label="Bad response"
    className={feedback === 'negative' ? 'selected' : ''}
  >
    <ThumbsDownIcon />
  </button>

  <button onClick={copyToClipboard} aria-label="Copy">
    <CopyIcon />
  </button>

  <button onClick={share} aria-label="Share">
    <ShareIcon />
  </button>
</div>
```

## Streaming & Real-Time UX

Progressive rendering of AI responses requires special handling:

```tsx
// Use Streamdown for AI streaming (handles incomplete markdown)
import { Streamdown } from '@vercel/streamdown';

// Auto-scroll management
useEffect(() => {
  if (shouldAutoScroll()) {
    messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' });
  }
}, [messages]);

// Smart auto-scroll heuristic
function shouldAutoScroll() {
  const threshold = 100; // px from bottom
  const isNearBottom =
    container.scrollHeight - container.scrollTop - container.clientHeight < threshold;
  const userNotReading = !hasUserScrolledUp && !isTextSelected;
  return isNearBottom && userNotReading;
}
```

For complete streaming patterns, auto-scroll behavior, and stop generation, see `references/streaming-ux.md`.

## Context Management

Communicate token limits clearly to users:

```tsx
// User-friendly token display
function TokenIndicator({ used, total }) {
  const percentage = (used / total) * 100;
  const remaining = total - used;

  return (
    <div className="token-indicator">
      <div className="progress-bar">
        <div className="progress-fill" style={{ width: `${percentage}%` }} />
      </div>
      <span className="token-text">
        {percentage > 80
          ? `⚠️ About ${Math.floor(remaining / 250)} messages left`
          : `${Math.floor(remaining / 250)} pages of conversation remaining`}
      </span>
    </div>
  );
}
```

For summarization strategies, conversation branching, and organization, see `references/context-management.md`.

## Multi-Modal Support

Handle images, files, and voice inputs:

```tsx
// Image upload with preview
function ImageUpload({ onUpload }) {
  return (
    <div
      className="upload-zone"
      onDrop={handleDrop}
      onDragOver={preventDefault}
    >
      <input
        type="file"
        accept="image/*"
        onChange={handleFileSelect}
        multiple
        hidden
        ref={fileInputRef}
      />
      {previews.map(preview => (
        <img key={preview.id} src={preview.url} alt="Upload preview" />
      ))}
    </div>
  );
}
```

For complete multi-modal patterns including voice and screen sharing, see `references/multi-modal.md`.

## Error Handling

Handle AI-specific errors gracefully:

```tsx
// Refusal handling
if (response.type === 'refusal') {
  return (
    <div className="error refusal">
      <Icon type="info" />
      <p>I cannot help with that request.</p>
      <details>
        <summary>Why?</summary>
        <p>{response.reason}</p>
      </details>
      <p>Try asking: {response.suggestion}</p>
    </div>
  );
}

// Rate limit communication
if (error.code === 'RATE_LIMIT') {
  return (
    <div className="error rate-limit">
      <p>Please wait {error.retryAfter} seconds</p>
      <CountdownTimer seconds={error.retryAfter} onComplete={retry} />
    </div>
  );
}
```

For comprehensive error patterns, see `references/error-handling.md`.

## Tool Usage Visualization

Show when AI is using tools or functions:

```tsx
function ToolUsage({ tool }) {
  return (
    <div className="tool-usage">
      <div className="tool-header">
        <Icon type={tool.type} />
        <span>{tool.name}</span>
        {tool.status === 'running' && <Spinner />}
      </div>
      {tool.status === 'complete' && (
        <details>
          <summary>View details</summary>
          <pre>{JSON.stringify(tool.result, null, 2)}</pre>
        </details>
      )}
    </div>
  );
}
```

For function calling, code execution, and web search patterns, see `references/tool-usage.md`.

## Implementation Guide

### Recommended Stack

Primary libraries (validated November 2025):

```bash
# Core AI chat functionality
npm install ai @ai-sdk/react @ai-sdk/openai

# Streaming markdown rendering
npm install @vercel/streamdown

# Syntax highlighting
npm install react-syntax-highlighter

# Security for LLM outputs
npm install dompurify
```

### Performance Optimization

Critical for smooth streaming:

```tsx
// Memoize message rendering
const MemoizedMessage = memo(Message, (prev, next) =>
  prev.content === next.content && prev.isStreaming === next.isStreaming
);

// Debounce streaming updates
const debouncedUpdate = useMemo(
  () => debounce(updateMessage, 50),
  []
);

// Virtual scrolling for long conversations
import { VariableSizeList } from 'react-window';
```

For detailed performance patterns, see `references/streaming-ux.md`.

### Security Considerations

Always sanitize AI outputs:

```tsx
import DOMPurify from 'dompurify';

function SafeAIContent({ content }) {
  const sanitized = DOMPurify.sanitize(content, {
    ALLOWED_TAGS: ['p', 'br', 'strong', 'em', 'code', 'pre', 'blockquote', 'ul', 'ol', 'li'],
    ALLOWED_ATTR: ['class']
  });

  return <Streamdown>{sanitized}</Streamdown>;
}
```

### Accessibility

Ensure AI chat is usable by everyone:

```tsx
// ARIA live regions for screen readers
<div role="log" aria-live="polite" aria-relevant="additions">
  {messages.map(msg => (
    <article key={msg.id} role="article" aria-label={`${msg.role} message`}>
      {msg.content}
    </article>
  ))}
</div>

// Loading announcements
<div role="status" aria-live="polite" className="sr-only">
  {isLoading ? 'AI is responding' : ''}
</div>
```

For complete accessibility patterns, see `references/accessibility.md`.

## Bundled Resources

### Scripts (Token-Free Execution)

- Run `scripts/parse_stream.js` to parse incomplete markdown during streaming
- Run `scripts/calculate_tokens.py` to estimate token usage and context limits
- Run `scripts/format_messages.js` to format message history for export

### References (Progressive Disclosure)

- `references/streaming-patterns.md` - Complete streaming UX patterns
- `references/context-management.md` - Token limits and conversation strategies
- `references/multimodal-input.md` - Image, file, and voice handling
- `references/feedback-loops.md` - User feedback and RLHF patterns
- `references/error-handling.md` - AI-specific error scenarios
- `references/tool-usage.md` - Visualizing function calls and tool use
- `references/accessibility-chat.md` - Screen reader and keyboard support
- `references/library-guide.md` - Detailed library documentation
- `references/performance-optimization.md` - Streaming performance patterns

### Examples

- `examples/basic-chat.tsx` - Minimal ChatGPT-style interface
- `examples/streaming-chat.tsx` - Advanced streaming with memoization
- `examples/multimodal-chat.tsx` - Images and file uploads
- `examples/code-assistant.tsx` - IDE-style code copilot
- `examples/tool-calling-chat.tsx` - Function calling visualization

### Assets

- `assets/system-prompts.json` - Curated prompts for different use cases
- `assets/message-templates.json` - Pre-built message components
- `assets/error-messages.json` - User-friendly error messages
- `assets/themes.json` - Light, dark, and high-contrast themes

## Design Token Integration

All visual styling uses the design-tokens system:

```css
/* Message bubbles use design tokens */
.message.user {
  background: var(--message-user-bg, var(--color-primary));
  color: var(--message-user-text, var(--color-white));
  padding: var(--message-padding, var(--spacing-md));
  border-radius: var(--message-border-radius, var(--radius-lg));
}

.message.ai {
  background: var(--message-ai-bg, var(--color-gray-100));
  color: var(--message-ai-text, var(--color-text-primary));
}
```

See `skills/design-tokens/` for complete theming system.

## Key Innovations

This skill provides industry-first solutions for:

- **Memoized streaming rendering** - 10-50x performance improvement
- **Intelligent auto-scroll** - User activity-aware scrolling
- **Token metaphors** - User-friendly context communication
- **Incomplete markdown handling** - Graceful partial rendering
- **RLHF patterns** - Effective feedback collection
- **Conversation branching** - Non-linear conversation trees
- **Multi-modal integration** - Seamless file/image/voice handling
- **Accessibility-first** - Built-in screen reader support

## Strategic Importance

This is THE most critical skill because:

1. **Perfect timing** - Every app adding AI (2024-2025 boom)
2. **No standards exist** - Opportunity to define patterns
3. **Meta-advantage** - Building WITH Claude = intimate UX knowledge
4. **Unique challenges** - Streaming, context, hallucinations all new
5. **Reference implementation** - Can become the standard others follow

Master this skill to lead the AI interface revolution.

© ancoleman · MIT · ancoleman/ai-design-components

Similar skills

All skills for Frontend and UI →

From the same set10

The whole set →
visualizing-data visualizing-data picks the right chart for your data and purpose, then helps build the dashboard or report with accessibility baked in. CX Codex +1 2installs architecting-networks architecting-networks is a Claude Code skill for choosing cloud network topologies: flat, multi-VPC, hub-and-spoke, or full mesh. It supports VPC, segmentation, and hybrid connectivity planning. CX Codex +1 1installs implementing-navigation implementing-navigation implements frontend navigation patterns and Python backend routing with built-in WCAG 2.1 AA accessibility guidelines. CX Codex +1 1installs security-hardening The security-hardening skill tightens OS, container, cloud, network, and database settings. Use it before production deployment, audits, or vulnerability review. CX Codex +1 1installs implementing-observability The implementing-observability skill wires metrics, logs and traces through OpenTelemetry and shows how to run Loki, Grafana, Tempo and Mimir yourself. Useful once one request crosses several services. CX Codex +1 1installs ingesting-data ingesting-data is a Claude Code skill with design patterns and code recipes for importing data from cloud storage, APIs, files, and streams into databases. CX Codex +1 1installs configuring-firewalls The configuring-firewalls skill guides firewall configuration across Linux hosts, cloud security controls, and Kubernetes. Use it when opening a service or narrowing network access. CX Codex +1 1installs building-ci-pipelines building-ci-pipelines — a skill for constructing secure CI/CD pipelines with SLSA provenance, monorepo optimization, caching strategies, and test parallelization. Works with GitHub Actions, GitLab CI, and Argo Workflows. CX Codex +1 1installs

Project sponsors

Companies that keep this analytics open