Skip to content

sergiovazquezdml/Base-de-datos-aluminio / .agents/skills/ai-spatial-voice-ux

AI, Spatial & Voice UX

Verified

Design patterns for AI-native interfaces, conversational UX, spatial computing (AR/VR/MR), voice interfaces, multimodal interaction design, and emerging interaction paradigms for 2025-2030.

references/ai-native-interface-patterns.md

View on GitHub
# AI-Native Interface Design Patterns

## Authoritative Reference for AI-First User Experience Design

This reference codifies the design patterns, interaction models, and UX principles that define AI-native interfaces. These patterns represent the evolving standard for building products where artificial intelligence is not an afterthought bolted onto existing UI but the foundational interaction paradigm around which the entire experience is architected.

---

## AI Chat Interface Design Patterns

### Message Threading and Branching Conversations

Design AI chat interfaces to support non-linear conversation structures. A single-thread linear chat fails users who need to explore multiple directions from a single prompt or revisit earlier points without losing subsequent context.

Implement **branching** by allowing users to select any previous message and create a new conversational fork from that point. Display branches visually using a tree structure, a tabbed interface, or a sidebar navigator that shows the conversation graph. Label each branch with an auto-generated summary or user-provided title so navigation remains intuitive even across dozens of branches.

Provide **message-level actions** on every AI response: regenerate (produce an alternative response from the same prompt), edit the original prompt and resubmit, branch into a new thread, or pin a particularly useful response. Show version history when a response has been regenerated multiple times, allowing users to compare outputs side by side.

For **collaborative threads**, support multiple users contributing to the same conversation. Display user avatars alongside messages, maintain a shared context, and provide conflict resolution when two users submit prompts simultaneously. Implement @-mention syntax to direct specific questions to specific participants or to instruct the AI to focus on a particular user's input.

### Context Window Management UI

Expose the AI's context window as a tangible, manageable resource. Users must understand what the AI currently "knows" and "sees" to form accurate mental models and craft effective prompts.

Display a **context usage indicator** showing the percentage of the context window consumed. Use a segmented progress bar that distinguishes between system prompt allocation, conversation history, attached files, and available remaining space. When the context window approaches capacity, surface a warning with actionable options: summarize and compress earlier messages, remove attached files, or start a new conversation with a summary handoff.

Implement a **context drawer** or panel that lists everything currently in the AI's working memory: uploaded documents, pasted code, referenced URLs, system instructions, and conversation history. Allow users to remove individual items from context, reorder their priority, or pin critical items that should never be evicted during automatic compression.

For **file and document context**, show clear indicators of which portions of attached documents the AI has processed. If a document exceeds context limits, communicate which pages or sections are included and which are truncated. Offer selective inclusion controls so users can specify the most relevant sections.

### Streaming Response Rendering

Render AI responses progressively as tokens arrive from the model. Never make users stare at a blank screen or a generic spinner when the AI is generating a multi-paragraph response.

Implement **progressive text rendering** that displays tokens as they stream in, with a subtle cursor or typing indicator at the insertion point. Maintain smooth scrolling behavior so the viewport follows new content without jarring jumps. Provide a "scroll to bottom" affordance that appears when the user scrolls up during generation, allowing them to catch up without being forced to watch every token appear.

Handle **markdown rendering progressively**: render headings, bold, and italic as soon as the relevant syntax markers are complete. For code blocks, switch to a monospace code renderer as soon as the opening triple-backtick and language identifier are detected. Render syntax highlighting in real-time as code tokens stream in. Apply the closing formatting only when the corresponding closing markers arrive.

For **structured content** like tables, lists, and mathematical expressions, use a two-phase render: display raw text during streaming, then reflow into the formatted representation once the structural element is complete. Provide a brief, smooth transition animation between raw and formatted states so users understand the transformation.

Allow **response interruption**: display a prominent "Stop generating" button during streaming. When triggered, keep all content generated so far and append a subtle indicator that the response was truncated by the user. Allow resumption with a "Continue generating" action.

### Multi-Turn Conversation Design

Design conversation flows that maintain coherent context across many turns while supporting natural topic transitions.

Implement **automatic topic detection** that segments long conversations into semantic sections. Display topic headers or dividers between distinct subjects so users can navigate conversation history by topic rather than scrolling through a monolithic thread. Allow collapsing of resolved topics to reduce visual clutter.

Support **explicit context injection** where users can reference earlier messages ("as I mentioned in my third message"), attached files ("based on the CSV I uploaded"), or external knowledge ("according to the documentation at [URL]"). Parse these references and visually link them to the source material so the AI's contextual understanding is transparent.

Handle **topic switching** gracefully. When a user abruptly changes subject, the AI interface should acknowledge the transition rather than conflating the new topic with the previous one. Offer to compartmentalize the new topic into a separate branch or explicitly carry forward only relevant context from the prior discussion.

Provide **conversation summaries** at configurable intervals. After every N turns or when the context window reaches a threshold, generate and display a collapsible summary of the conversation so far. Allow users to edit these summaries to correct misunderstandings before they propagate through subsequent context.

### System Prompts and Persona Selection UI

Expose system prompt configuration as a first-class feature for power users while keeping it invisible to casual users.

Design a **persona selector** that presents curated AI personalities or specialized modes as cards or chips at the start of a conversation. Each persona card should display: a name, a brief description of the persona's expertise and communication style, recommended use cases, and any capability differences. Examples: "Code Reviewer" (technical, precise, references best practices), "Creative Writer" (imaginative, expressive, exploratory), "Data Analyst" (quantitative, visualization-oriented, methodical).

For **custom system prompts**, provide a dedicated editor with syntax highlighting for template variables, character count relative to context budget, and a "Test" button that generates a sample response so users can evaluate the persona before committing. Store custom personas in a library with tagging, search, and sharing capabilities.

Display the **active persona** prominently in the conversation header. Allow mid-conversation persona switching with a clear indicator in the message thread showing where the switch occurred. Warn users that switching personas may alter the AI's interpretation of earlier context.

### Conversation Management

Build robust infrastructure for organizing, searching, and sharing conversation history.

Implement **automatic titling** that generates a descriptive conversation title from the first few exchanges. Allow manual title editing. Support folder organization with drag-and-drop, tagging with custom labels, and starring for quick access to important conversations.

Provide **full-text search** across all conversations with filters for date range, persona used, file types attached, and conversation length. Display search results with highlighted matching text and surrounding context, linking directly to the relevant position in the conversation.

For **sharing**, generate shareable links with configurable permissions: view-only, view-and-branch (recipients can fork the conversation), or full collaborative access. Support exporting conversations to markdown, PDF, or JSON formats. When sharing, allow redaction of specific messages or attachments that contain sensitive information.

Implement **archival and deletion** with clear data retention policies. Show users exactly what data is stored, for how long, and whether it is used for model training. Provide bulk operations for managing conversation history at scale.

---

## AI Copilot Patterns (Embedded AI in Tools)

### Inline Suggestions

Design inline AI suggestions that feel like a natural extension of the user's creative process rather than an interruption.

**Trigger conditions** must be carefully calibrated. Generate suggestions after a meaningful pause in typing (300-600ms), at natural code or text boundaries (end of a line, after a punctuation mark), or when the user explicitly invokes suggestions via a keyboard shortcut. Never trigger suggestions during active typing or mid-word, as this breaks flow and trains users to ignore the feature.

**Display suggestions** as ghost text in a muted color that is clearly distinguishable from user-authored content but still legible. For multi-line suggestions, show the first 2-3 lines inline and indicate additional content with a subtle "more" indicator. Position the suggestion at the cursor location, maintaining the document's existing formatting and indentation.

**Accept/reject interactions** must be frictionless. Accept with Tab, reject by continuing to type (the suggestion should dissolve without requiring explicit dismissal), cycle through alternative suggestions with a keyboard shortcut, or partially accept word-by-word with a modifier key combination. Never require mouse interaction for the primary accept/reject flow.

Show a **confidence indicator** alongside each suggestion: a small dot or bar that conveys the model's certainty. High-confidence suggestions can be displayed more prominently; low-confidence suggestions should be more subdued or require explicit invocation.

### AI Sidebar Panel

Design contextual AI assistance panels that complement the user's primary workflow without competing for attention.

Position the sidebar to the right of the main content area with a default width of 320-400px. Make it collapsible to an icon-only rail and resizable by dragging the edge. Maintain sidebar state across sessions so users do not need to reconfigure it each time they open the application.

Populate the sidebar **contextually**: when the user selects code, show explanation, refactoring suggestions, and documentation links. When the user highlights text, offer rewriting, summarization, and translation. When the user is on a settings page, provide guidance on configuration options. The sidebar's content should update automatically as the user's focus changes, with a brief delay to avoid distracting rapid updates.

Include a **chat input** at the bottom of the sidebar for ad-hoc questions about the current context. Responses appear in the sidebar's scrollable area. Support referencing the current selection, current file, or current project as implicit context without requiring the user to copy-paste.

### AI-Powered Search and Command Palette

Integrate AI understanding into search and command interfaces to bridge the gap between user intent and system capabilities.

Enhance the **command palette** (Cmd/Ctrl+K pattern) with natural language understanding. When a user types "make the header bigger," interpret this as an intent to modify font size or heading level and present the relevant commands with their keyboard shortcuts. Show the AI's interpretation of the query alongside traditional fuzzy-matched command results so users can learn the canonical command names over time.

Implement **semantic search** across project files, documentation, and settings. Go beyond keyword matching to understand queries like "where do we handle authentication errors" and return relevant code locations, configuration files, and documentation sections ranked by relevance. Display search results with AI-generated summaries explaining why each result is relevant to the query.

### Smart Autocomplete with Confidence Indicators

Extend traditional autocomplete with AI-powered predictions that go beyond simple prefix matching.

Display autocomplete suggestions in a dropdown with each item showing: the suggested completion, a brief explanation of why it is suggested, and a confidence bar. Group suggestions by source: "From your recent usage," "From project conventions," "AI-predicted." Allow users to configure the balance between conservative (high-confidence only) and aggressive (more suggestions, lower threshold) autocomplete behavior.

### AI-Driven Form Filling and Data Extraction

Design patterns for AI that automatically populates form fields from unstructured input.

Provide a **paste-and-parse** zone where users can paste or drop unstructured text (an email, a receipt, a business card photo) and the AI extracts structured data into form fields. Show the extraction results with field-level confidence indicators: green for high confidence, yellow for uncertain, red for fields that could not be extracted. Allow one-click correction on any field by clicking the confidence indicator to see alternatives.

Implement **progressive extraction** that updates in real-time as the user provides additional unstructured input. Maintain a visual mapping between source text and extracted fields so users can verify accuracy by tracing from the form field back to the source material.

---

## AI Agent Patterns

### Task Delegation UI

Design interfaces for describing and delegating complex tasks to autonomous AI agents.

Provide a **task description** input that supports both natural language and structured templates. Offer template starters for common task types: "Research and summarize [topic]," "Refactor [code section] to [objective]," "Generate a [document type] based on [inputs]." Parse the natural language description and display the AI's understanding of the task as a structured breakdown: objective, constraints, expected outputs, and estimated scope. Allow the user to confirm, modify, or reject the interpretation before execution begins.

Include **scope controls** that constrain the agent's authority: which files it may modify, which APIs it may call, what budget (time, tokens, API calls) it may consume, and what actions require human approval. Present these controls as a permissions checklist with sensible defaults that err on the side of caution.

### Progress Monitoring

Provide real-time visibility into agent execution so users maintain situational awareness without needing to micromanage.

Display a **step-by-step execution log** showing each action the agent takes: files read, searches performed, code written, tests run, external APIs called. Use a timeline or vertical stepper visualization with status indicators (completed, in-progress, queued, failed) for each step. Allow expanding any step to see full details: inputs, outputs, duration, and token usage.

Show a **progress summary** at the top of the monitoring view: percentage complete (if estimable), elapsed time, tokens consumed, and a one-sentence description of what the agent is currently doing. Provide a live preview of any artifacts being generated (documents, code files, images) so users can intervene early if the agent is heading in the wrong direction.

### Approval Gates

Implement human-in-the-loop checkpoints for critical or irreversible actions.

Define **approval categories** based on risk level: informational (the agent notifies but does not pause), advisory (the agent recommends and pauses briefly but auto-proceeds if no response), mandatory (the agent halts until explicit human approval). Allow users to configure which actions fall into each category based on their risk tolerance and the sensitivity of the task.

Design the **approval interface** as a concise decision card: what the agent wants to do, why it believes this action is necessary, what the consequences will be, and what alternatives exist. Provide "Approve," "Modify," and "Reject" actions. For "Modify," open an inline editor where the user can adjust the proposed action before the agent proceeds. For "Reject," prompt the user for guidance on how to proceed alternatively.

Batch related approval requests to avoid notification fatigue. If an agent needs approval for five similar file modifications, present them as a single grouped approval with individual override capability rather than five separate interruptions.

### Result Review and Correction Interface

Design review interfaces that make it efficient to evaluate, accept, and correct agent outputs.

Present results using a **diff view** for any modifications to existing content: side-by-side or unified diff with syntax highlighting, line-level accept/reject controls, and inline commenting. For newly generated content, provide a structured review with section-level approve/reject and an integrated editing experience.

Implement **correction propagation**: when a user corrects one instance of an error, offer to apply the same correction pattern across all similar instances in the agent's output. Track corrections as feedback that can improve future agent behavior on similar tasks.

### Autonomous vs. Supervised Mode Toggle

Provide a clear, prominent toggle between autonomous and supervised operation modes.

In **autonomous mode**, the agent executes tasks end-to-end with minimal interruption, only pausing for mandatory approval gates. Display a compact monitoring widget (minimizable to a status bar indicator) that shows progress without demanding attention.

In **supervised mode**, the agent pauses after each significant step for user review and approval. Display the full execution log with step-by-step controls: approve and continue, modify and continue, or abort.

Support **hybrid mode** where users define specific phases or action types that require supervision while others proceed autonomously. Visualize the execution plan upfront with supervision checkpoints clearly marked so users know when they will need to be available for approvals.

---

## Generative UI Patterns

### AI-Generated Forms Based on User Intent

Design systems where the AI constructs form interfaces dynamically based on what the user describes wanting to accomplish.

When a user expresses an intent ("I need to submit a bug report" or "Help me plan a trip"), generate a contextually appropriate form with relevant fields, sensible defaults, and inline guidance. Show the form generation process briefly (a skeleton loading state) to establish that the AI is constructing something custom rather than presenting a static template.

Allow **iterative form refinement**: the user can request additional fields ("also ask about priority"), field modifications ("make the date field a range picker"), or simplification ("remove the optional fields") through natural language. The form updates in place with smooth animations that help users track what changed.

### Dynamic Dashboard Creation from Natural Language

Enable users to describe the data view they need and have the AI construct an appropriate visualization dashboard.

Parse natural language queries like "show me sales by region over the last quarter with a trend line" into structured visualization specifications. Present the generated dashboard with a brief annotation explaining the AI's interpretation: data source, chart type selection rationale, and any assumptions made. Provide inline controls to adjust every aspect: change chart types, modify date ranges, add or remove metrics, and alter groupings.

Support **dashboard evolution** where users iteratively refine through conversation: "break this down by product category," "add a comparison to last year," "highlight anything that's down more than 10%." Each modification applies incrementally, preserving the user's previous customizations.

### Personalized Interface Adaptation

Design AI systems that adapt the interface to individual usage patterns over time.

Track **interaction patterns** to identify frequently used features, common workflows, and underutilized capabilities. Use this data to suggest interface customizations: reordering menu items, surfacing shortcuts for common actions, or collapsing rarely used sections. Always present adaptations as suggestions that users can accept, reject, or modify rather than silently reorganizing the interface.

Implement **progressive disclosure** driven by usage maturity: new users see a simplified interface with guidance, and as the system detects increasing proficiency, it surfaces more advanced features and reduces hand-holding. Always maintain easy access to the full feature set regardless of the system's assessment of user proficiency.

### Content Summarization and Expansion Controls

Provide universal controls for adjusting AI-generated content density.

Implement a **detail slider** or discrete level selector (Summary / Standard / Detailed / Comprehensive) that adjusts the verbosity of AI-generated content across the interface. Apply this control consistently: in chat responses, in generated documents, in dashboard annotations, and in help text. Maintain the same semantic content across levels, varying only the depth and elaboration.

For individual content blocks, provide inline **expand/collapse** controls that request more detail on a specific section without regenerating the entire response. Track which sections users expand most frequently and adjust default detail levels accordingly.

---

## AI Transparency Patterns

### Confidence Indicators

Communicate AI certainty explicitly so users can calibrate their trust appropriately.

Use **visual confidence indicators** scaled to the precision they communicate: a three-level indicator (high/medium/low) for subjective assessments, a percentage or five-point scale for quantifiable predictions, and explicit verbal hedging ("I believe," "It's possible that," "I'm not certain, but") for conversational AI. Match the granularity of the indicator to the meaningful granularity of the underlying confidence.

Display confidence at the **appropriate scope**: per-response for chat interfaces, per-field for form extraction, per-suggestion for autocomplete, per-step for agent actions. Avoid showing a single overall confidence score when the response contains multiple claims with varying certainty.

Implement **confidence calibration** transparency: show users historical accuracy data for each confidence level. "When this model says it's 80% confident, it's historically correct 82% of the time" builds informed trust.

### Source Attribution

Link AI outputs to their informational sources whenever possible.

Display **inline citations** as numbered references or clickable superscripts that link to source documents, URLs, or specific passages. For each citation, show a preview card on hover with the source title, relevant excerpt, and publication date. Group citations in a references section at the end of longer responses.

Distinguish between **source types**: direct quotes from retrieved documents, paraphrased information from training data, synthesized conclusions drawn from multiple sources, and the model's own reasoning without specific sources. Use different visual treatments for each type so users understand the epistemic basis of each claim.

### Reasoning Visibility

Expose the AI's reasoning process to build understanding and enable error detection.

Implement a **chain-of-thought disclosure** that shows the AI's step-by-step reasoning in a collapsible section. Default to collapsed for routine responses and expanded for high-stakes decisions, complex analyses, or when the AI's conclusion is surprising. Format reasoning steps as a numbered list with clear logical connections between steps.

For **tool-using AI**, show which tools were invoked, in what order, with what parameters, and what each tool returned. Display this as an execution trace that users can inspect to verify the AI followed a reasonable process, not just a reasonable output.

### Model Identification

Always disclose which AI model is producing responses.

Display the **model name and version** in a consistent location: the conversation header, a status bar, or a subtle label on each response. When the model changes mid-conversation (due to fallback, load balancing, or user selection), mark the transition clearly in the conversation thread.

Provide a **model info** tooltip or panel that describes the model's capabilities, training data cutoff date, known limitations, and any safety filters active in the current configuration. Keep this information accessible but not intrusive.

### Limitations Disclosure

Proactively communicate what the AI cannot do, does not know, and should not be relied upon for.

Display **capability boundaries** at appropriate moments: when a user asks about events after the training cutoff, when the query requires real-time data the model does not have access to, when the task involves domains with known model weaknesses, or when the requested output type is not well-supported. Frame limitations as specific and actionable ("I don't have access to real-time stock prices; here's where you can find that") rather than vague disclaimers.

---

## AI Error Patterns

### Hallucination Detection and Flagging

Design interfaces that help users identify and handle AI confabulation.

Implement **automated verification** where feasible: fact-check generated claims against authoritative sources, verify code suggestions compile and pass tests, confirm that cited references actually exist. Flag unverifiable claims with a distinct visual indicator (a warning icon, a different text color, a margin annotation) and explain why verification failed.

For **user-reported hallucinations**, provide a one-click "This is incorrect" action on any AI statement. Prompt the user for the correct information and use this feedback to annotate the conversation, correct downstream dependencies on the hallucinated information, and optionally feed back into model improvement pipelines.

Design **verification workflows** for high-stakes content: before finalizing AI-generated legal text, medical information, financial advice, or technical specifications, present a structured review checklist that encourages users to verify key claims rather than accepting the output wholesale.

### Graceful Degradation When AI Is Unavailable

Design fallback experiences that maintain functionality when AI services are unreachable.

Implement **tiered degradation**: first, switch to a cached or smaller local model that can handle basic requests; second, fall back to traditional non-AI functionality (rule-based autocomplete, keyword search, manual form filling); third, display a clear status message with estimated recovery time and manual alternatives.

Cache **recent AI outputs** locally so that previously generated content remains accessible even during outages. For generative features, maintain a library of templates and pre-generated content that can substitute for real-time AI generation.

### Rate Limiting and Quota Communication

Communicate usage limits clearly and help users optimize their AI consumption.

Display **usage dashboards** showing current consumption against limits: requests made, tokens used, time until reset. Provide real-time estimates of token cost before sending long prompts or large file attachments. Warn users when they are approaching limits with enough lead time to adjust their behavior.

When a **rate limit is hit**, provide specific information: how long until the limit resets, whether upgrading their plan would increase limits, and what they can do in the meantime. Never show a generic error message when the cause is a known quota limitation.

### Model Fallback Strategies

Design transparent fallback when the primary AI model is unavailable or unsuitable.

Implement **automatic fallback** with clear disclosure: "The primary model is currently unavailable. This response was generated by [fallback model], which may differ in quality or capabilities." Display the fallback notice prominently enough that users notice it but not so alarmingly that it undermines confidence in the response.

Allow users to **queue requests** for the primary model if they prefer to wait rather than accept fallback output. Show estimated wait times and allow cancellation with fallback at any point during the wait.

---

## Trust Calibration

### Progressive Autonomy

Design systems where AI gradually earns broader authority through demonstrated competence.

Start new users or new task types in **supervised mode** with frequent approval gates. As the AI demonstrates accuracy and the user develops comfort, offer to reduce supervision for task categories where the AI has a strong track record. Display the AI's historical performance for each task type when proposing autonomy increases.

Implement **autonomy levels** as a per-task-type setting: Level 1 (suggest only), Level 2 (act with confirmation), Level 3 (act and notify), Level 4 (act silently). Track and display the criteria for advancing levels: number of successful completions, error rate, user satisfaction ratings.

Never **auto-promote** autonomy levels without explicit user consent. Present promotions as recommendations with supporting evidence, and allow users to demote at any time without penalty or friction.

### Trust Indicators

Provide persistent, contextual indicators that help users assess AI reliability.

Display **accuracy history** for the current task type: "This model has been 94% accurate on code review suggestions over your last 200 interactions." Update these statistics in real-time and make the methodology transparent (what counts as "accurate," how are ambiguous cases handled).

Implement **verification badges** for AI outputs that have been confirmed by external sources, approved by human reviewers, or validated by automated testing. Distinguish clearly between unverified AI output and output that has passed one or more verification gates.

### User Feedback Loops

Design lightweight, consistent mechanisms for users to evaluate and correct AI outputs.

Place **thumbs up/down** controls on every AI-generated element, from chat responses to inline suggestions to agent actions. Make the feedback action require exactly one click with no modal dialogs or required explanations. Offer an optional "Tell us more" expansion for users willing to provide detailed feedback.

Implement **correction interfaces** that are specific to the output type: inline text editing for generated content, alternative selection for classification outputs, parameter adjustment for generated visualizations. Feed corrections back into the user's personalization profile so the same error is less likely to recur in that user's experience.

Show users the **impact of their feedback**: "Based on your corrections, we've improved suggestions for [category] by [metric]." This closes the feedback loop and motivates continued participation.

### Appropriate Reliance

Design patterns that calibrate user trust to match actual AI capability, combating both over-trust and under-trust.

For **over-trust mitigation**, require explicit user verification for high-stakes outputs. Introduce strategic friction (a confirmation dialog, a brief delay, a mandatory review step) before AI-generated content is published, code is committed, or transactions are executed. Periodically surface reminders that AI output requires human judgment, especially for users who consistently accept outputs without review.

For **under-trust mitigation**, surface success metrics and track record data for users who rarely engage AI features. Offer guided tours that demonstrate AI capabilities in low-stakes contexts. Provide an "AI suggested this 3 minutes ago" indicator when a user manually arrives at the same conclusion the AI had already suggested, building retrospective confidence.

---

## Ethical AI UX

### Bias Disclosure and Mitigation

Design interfaces that acknowledge and help counteract AI bias.

Provide **bias warnings** when the AI operates in domains with known demographic, cultural, or historical biases. Frame warnings specifically: "Language models may reflect biases present in their training data, which can affect [specific aspect of this output]." Pair warnings with actionable guidance: "Consider reviewing this output for [specific bias type] before using it for [specific purpose]."

Implement **diverse perspective prompts** for subjective content: after generating an opinion-laden or culturally situated response, offer to "Show alternative perspectives" that present the topic from different cultural, demographic, or ideological viewpoints.

### Content Filtering UX

Design safety controls that feel protective rather than punitive.

Implement **configurable safety levels** that users can adjust based on their context and needs. Display safety settings as a spectrum rather than binary on/off, with clear descriptions of what each level filters and why. For professional contexts (medical education, security research, content moderation), provide documented pathways to access content that would be filtered in consumer contexts.

When content is **filtered or modified**, explain specifically what was changed and why, rather than silently omitting content or showing vague "content policy" messages. Offer appeal or feedback mechanisms for users who believe content was incorrectly filtered.

### Data Privacy Controls for AI Features

Design granular, comprehensible privacy controls for AI-powered functionality.

Provide a **dedicated AI privacy panel** that clearly describes: what data is sent to AI models, whether data is used for model training, how long data is retained, where data is processed (on-device vs. cloud), and what third parties have access. Use plain language, not legal jargon, and provide concrete examples for each data category.

Implement **per-feature privacy controls** rather than a single global toggle. Users may be comfortable with AI-powered autocomplete processing their text but uncomfortable with AI analytics processing their usage patterns. Present each AI feature's data requirements independently with individual enable/disable controls.

Support **on-device AI processing** where feasible and label features that operate entirely locally. Display a clear "cloud" or "on-device" indicator on every AI feature so users always know whether their data leaves their device.

### Opt-In vs. Opt-Out for AI-Powered Features

Default to opt-in for AI features that process user content or alter user workflows.

Implement **progressive opt-in** that introduces AI features one at a time with clear value propositions. When a user first encounters an AI feature, show a brief, non-modal introduction: what the feature does, what data it uses, and a one-click enable action. Do not pre-check opt-in checkboxes or use dark patterns to increase AI feature adoption.

For features that are **enabled by default** (because they are core to the product's value proposition), provide a prominent, persistent opt-out mechanism in the feature's UI, not buried in settings. Display a first-run notice explaining the feature's AI-powered nature and how to disable it.

Respect **opt-out comprehensively**: when a user disables an AI feature, stop all associated data processing immediately, provide a non-AI alternative workflow, and do not repeatedly prompt the user to re-enable the feature. Limit re-engagement prompts to major updates that materially change the feature's capabilities or privacy characteristics.

---

## Summary of Core Principles

1. **Transparency over magic**: always help users understand what the AI is doing, why, and with what confidence.
2. **User agency over automation**: maintain human control at every decision point, especially for irreversible actions.
3. **Progressive trust over blind faith**: build the AI-human relationship incrementally through demonstrated competence.
4. **Graceful degradation over hard failure**: always provide a path forward when AI falters.
5. **Privacy by design over privacy by policy**: build data minimization and user control into the architecture, not just the terms of service.
6. **Inclusive design over majority optimization**: ensure AI interfaces serve diverse users, contexts, and abilities.
7. **Honest limitations over confident hallucinations**: an AI that says "I don't know" is more trustworthy than one that fabricates answers.
8. **Feedback integration over static deployment**: design every AI interface as a learning system that improves from user interaction.

These patterns will continue to evolve as AI capabilities advance and user expectations mature. Revisit and revise these guidelines as new interaction paradigms emerge and as empirical research provides deeper understanding of human-AI interaction dynamics.
brainstormingobra/superpowersYou MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation).Stars: 322kUpdated Claude CodeCodexVerifiedInstall
brand-guidelinesanthropics/skillsApplies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
frontend-designanthropics/skillsGuidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
mcp-builderanthropics/skillsGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).Stars: 198kUpdated Claude CodeCodexVerifiedInstall