Skip to content

sergiovazquezdml/Base-de-datos-aluminio / .agents/skills/agentic-ai-generative-ux

Agentic AI & Generative UX

Verified

Design patterns for agentic AI systems, multi-agent orchestration, generative UI, RAG interfaces, AI safety guardrails, trust calibration, and the paradigm shift from tool-based to agent-based interfaces. Covers AI copilot frameworks, prompt engineering UX, and AI anti-patterns.

references/llm-hallucination-design-guardrails.md

View on GitHub
# LLM Hallucination Design Guardrails — Trust Through Transparency

Large language models generate plausible but sometimes fabricated outputs. When these outputs reach end users through AI-powered interfaces, the consequences range from mild confusion to dangerous misinformation. Designing guardrails around hallucination is not merely a backend engineering problem — it is fundamentally a UX challenge. Users need interfaces that communicate certainty and uncertainty, make verification effortless, and establish calibrated trust. This reference catalogs hallucination types, detection strategies, confidence visualization patterns, verification UX, graceful uncertainty expression, user feedback mechanisms, quality gates, and implementation approaches grounded in recent research.

---

## 1. Hallucination Taxonomy

### Factual Hallucination

**Definition.** The model generates a statement that contradicts established fact. Examples include fabricated statistics, incorrect dates, wrong attributions (e.g., "Einstein discovered penicillin"), or invented scientific claims.

**UI impact.** Users who trust factual hallucinations may make poor decisions, share misinformation, or lose trust in the product entirely when errors are eventually discovered. Factual hallucination is the most frequently discussed category because its consequences are the most immediately verifiable and potentially harmful.

### Citation and Attribution Hallucination

**Definition.** The model generates plausible-looking references — paper titles, journal names, URLs, author names — that do not exist or do not support the claim they are attached to. The model may combine real author names with fabricated paper titles or real paper titles with fabricated findings.

**UI impact.** Citation hallucination is particularly insidious because it creates a false sense of verification. Users who see a citation assume the claim has been sourced. Interfaces that display AI-generated citations without validation actively undermine trust when users follow dead links or discover non-existent papers.

### Structural and Format Hallucination

**Definition.** The model produces output that follows the requested structure but fills it with fabricated content. For example, when asked to generate a JSON schema, the model may invent field names that do not exist in the actual API. When asked for a code example, it may reference libraries or functions that do not exist.

**UI impact.** Developers and technical users copy structured outputs into their work. Fabricated API fields, non-existent function signatures, or incorrect configuration formats cause downstream failures that are often difficult to debug because the output "looked right."

### Visual and Multimodal Hallucination

**Definition.** In multimodal models, hallucination extends to visual interpretation. The model may describe objects in images that are not present, misidentify people, generate images with incorrect details (wrong number of fingers, misread text), or misinterpret charts and graphs.

**UI impact.** Users with visual impairments relying on AI-generated image descriptions receive incorrect information. Users trusting AI-interpreted data visualizations may draw wrong conclusions. Generated images may contain subtle errors that spread misinformation.

### Consistency and Contradiction Hallucination

**Definition.** The model contradicts itself within the same response or across turns in a conversation. It may assert X in paragraph one and not-X in paragraph three, or agree with a user's incorrect correction, abandoning a previously correct answer.

**UI impact.** Self-contradiction erodes trust and creates confusion. Users cannot determine which statement to believe. In conversational interfaces, sycophantic contradiction (where the model agrees with the user's wrong premise) is especially dangerous because it reinforces user misconceptions.

### Temporal and Outdated Hallucination

**Definition.** The model presents outdated information as current, conflates events from different time periods, or fabricates recent events by extrapolating from training data patterns. The model may describe a company's product lineup based on training data from two years prior, missing significant changes.

**UI impact.** Users seeking current information receive stale or fabricated updates. This is particularly harmful in domains where recency matters: medical guidelines, software documentation, legal regulations, financial data.

---

## 2. Detection Patterns

### Confidence Scoring

Assign a numerical confidence score to model outputs based on token-level probabilities, calibrated against known benchmarks. Low-probability token sequences suggest the model is "guessing" rather than recalling reliable patterns.

- **Token-level entropy.** High entropy across output tokens indicates uncertainty.
- **Sequence-level probability.** The joint probability of the entire generated sequence provides a holistic confidence measure.
- **Calibration.** Raw model probabilities are often poorly calibrated. Apply temperature scaling or Platt scaling to align stated confidence with empirical accuracy.

### Self-Consistency Checks

Generate multiple responses to the same prompt (using sampling with temperature > 0) and compare them. Consistent answers across samples suggest reliability; divergent answers suggest hallucination risk.

- **Majority voting.** Take the most common answer across N samples.
- **Semantic clustering.** Group semantically similar responses and measure cluster coherence.
- **Disagreement flagging.** When samples diverge significantly, flag the output for user verification.

### Retrieval-Augmented Verification

After generation, retrieve relevant documents from a trusted knowledge base and compare the generated claims against retrieved evidence. This is distinct from retrieval-augmented generation (RAG) — it is a post-generation verification step.

- **Claim extraction.** Parse the generated text into discrete factual claims.
- **Evidence retrieval.** For each claim, retrieve the top-K relevant passages from a trusted corpus.
- **Entailment scoring.** Use a natural language inference (NLI) model to score whether retrieved evidence supports, contradicts, or is neutral toward each claim.

### Citation Validation

When the model generates citations, validate them programmatically:

- **URL validation.** Check that cited URLs resolve (HTTP HEAD request).
- **DOI lookup.** Verify DOIs against CrossRef or Semantic Scholar APIs.
- **Content verification.** If the cited source is accessible, check that it actually supports the claim made.

### Semantic Entailment Checking

Use a secondary model or specialized NLI model to check whether generated conclusions logically follow from provided premises. This is especially useful when the primary model is performing reasoning or analysis.

---

## 3. Confidence Indicator Design

### Visual Encoding

Design a visual language for communicating confidence levels to users. Research suggests three tiers are more usable than continuous scales.

**High confidence (verified or well-supported):**
- Solid filled badge or icon in a muted, trustworthy color (e.g., subdued green or blue).
- No additional decoration — high confidence should be the default, unobtrusive state.

**Medium confidence (plausible but unverified):**
- Partially filled badge or icon. A half-filled circle or a dashed outline conveys partiality.
- Optional tooltip: "This information is likely correct but has not been verified against sources."

**Low confidence (uncertain or potentially fabricated):**
- Outline-only badge or icon, often in amber or warm gray.
- Inline warning text: "This claim could not be verified. Please check the sources."
- Consider a subtle visual treatment on the text itself (e.g., lighter font weight, italics, or a background tint) to signal reduced certainty.

### Placement Strategies

**Inline placement.** Confidence indicators appear next to individual claims within the text. Best for responses containing a mix of high- and low-confidence statements. More granular, but can create visual noise.

**Message-level placement.** A single confidence indicator appears at the top or bottom of the entire response. Simpler and less noisy, but less informative when confidence varies across claims.

**Section-level placement.** For long, structured responses, confidence indicators appear at the section or paragraph level. A good middle ground between inline and message-level.

### User Calibration

Research by Vasconcelos et al. (arXiv:2302.09095) found that users often miscalibrate their trust in AI confidence indicators — they either over-rely on high-confidence signals or ignore low-confidence warnings. Design recommendations from this work:

- **Anchor confidence to concrete accuracy rates.** Instead of abstract terms like "high confidence," show "Historically accurate 92% of the time for this type of question."
- **Provide calibration training.** On first use, show users examples of correct and incorrect AI outputs with their confidence levels to build intuition.
- **Avoid confidence inflation.** Never display confidence higher than the system's empirical accuracy warrants. Overconfident systems destroy trust faster than uncertain-but-honest ones.

---

## 4. Verification UX Patterns

### One-Click Source Verification

Provide a prominent, low-friction mechanism for users to verify claims against sources. A single click should open the relevant source, scrolled to the supporting passage.

```
[AI-generated claim] [Verify ↗]
```

The "Verify" affordance should be visually distinct but not disruptive. A small icon-button or text link positioned at the end of the claim works well.

### Inline Citations with Preview

Attach inline citations (numbered references or superscripts) to specific claims. On hover or click, show a preview card with the source title, relevant excerpt, publication date, and a link to the full source.

```
The average human attention span has not declined to 8 seconds [1].

[1] "Attention span: Not shrinking." — Bradbury (2023), Nature Human Behaviour
    "The widely cited 'goldfish' statistic has no traceable origin in
     peer-reviewed research..."
    [Open source →]
```

### Fact-Check Integration

For high-stakes domains (health, legal, financial), integrate with external fact-checking services or knowledge bases. Display verification status alongside AI-generated claims.

- **Verified** — claim matches trusted sources.
- **Disputed** — conflicting information found.
- **Unverifiable** — no relevant sources found to confirm or deny.

### "Verify This" Affordance

Provide an explicit action that triggers deeper verification. When a user clicks "Verify this," the system performs retrieval-augmented verification and displays the evidence alongside the claim, letting the user judge for themselves.

### Comparison View

For complex or high-stakes responses, offer a split-pane or tabbed view showing the AI's output alongside the source material it drew from. Users can visually compare claims against evidence, building their own judgment.

---

## 5. "I Don't Know" Design

### Honest Uncertainty Expression

Design the AI to express uncertainty clearly and without hedging excessively. The goal is to be helpful even when uncertain, not to refuse all difficult questions.

**Patterns for expressing uncertainty in the UI:**

- **Direct admission.** "I don't have reliable information about this topic." Displayed in a distinct visual container (e.g., an info card with an appropriate icon).
- **Bounded admission.** "I can answer the general question, but I don't have data from after March 2025." Clearly communicates what the model can and cannot do.
- **Redirect.** "I'm not confident in my answer here. For up-to-date information on drug interactions, consult a pharmacist or check [trusted-source.org]." Provides an alternative path.
- **Partial answer with caveats.** "Based on general knowledge, X is likely true, but I haven't verified this against current sources. Key caveats: [list]." Delivers value while being transparent about limitations.

### UI Component Examples

**Uncertainty card:**

```
┌─────────────────────────────────────────┐
│  ⓘ  Limited confidence                  │
│                                         │
│  I can provide general information      │
│  about this topic, but my training      │
│  data may not include recent changes.   │
│                                         │
│  [Show what I know]  [Find current sources] │
└─────────────────────────────────────────┘
```

**Partial answer with caveat bar:**

```
┌─────────────────────────────────────────┐
│  ⚠ Parts of this answer are unverified  │
└─────────────────────────────────────────┘

  The regulation was last updated in 2023
  to include provisions for...

  ┌─ Unverified ──────────────────────┐
  │  The penalty amounts may have     │
  │  changed. Verify at [source].     │
  └───────────────────────────────────┘
```

---

## 6. User Error Reporting

### Thumbs Down

The simplest feedback mechanism. A thumbs-down button on every AI response captures binary dissatisfaction. Lightweight but low-information — you know something was wrong but not what.

### Detailed Flag

After thumbs-down, offer a categorized flag:

- **Factually incorrect** — the information is wrong.
- **Outdated** — the information was once correct but is no longer.
- **Irrelevant** — the response does not address the question.
- **Harmful or offensive** — the response contains dangerous or inappropriate content.
- **Citation error** — a cited source does not exist or does not support the claim.

### Suggested Correction

Allow users to provide the correct information alongside their flag. This creates a valuable training signal and makes users feel their feedback has impact.

```
┌─────────────────────────────────────────┐
│  What was wrong with this response?     │
│                                         │
│  ○ Factually incorrect                  │
│  ○ Outdated information                 │
│  ○ Irrelevant to my question            │
│  ○ Citation error                       │
│  ○ Other                                │
│                                         │
│  Correct answer (optional):             │
│  ┌─────────────────────────────────┐    │
│  │                                 │    │
│  └─────────────────────────────────┘    │
│                                         │
│  [Submit feedback]                      │
└─────────────────────────────────────────┘
```

### Feedback Loop to Improve System

Close the loop with users. When their feedback leads to a system improvement, notify them: "Thanks to your feedback, we corrected this response." This builds trust and encourages continued participation. Aggregate error reports to identify systematic hallucination patterns (e.g., the model consistently hallucinates about a specific topic) and prioritize targeted fixes.

---

## 7. AI Quality Gates

### NNGroup "AI Slop" Concept

Nielsen Norman Group's 2024-2025 research on "AI slop" describes low-quality AI output that technically responds to the prompt but provides little genuine value — verbose, generic, inaccurate, or poorly structured content. Quality gates prevent AI slop from reaching users.

### Output Quality Scoring

Score every AI output on multiple dimensions before displaying it to the user:

- **Relevance.** Does the response address the user's actual question?
- **Factual grounding.** Can key claims be traced to retrieved sources?
- **Specificity.** Does the response contain concrete, actionable information rather than vague generalities?
- **Conciseness.** Is the response appropriately sized for the question complexity?
- **Consistency.** Does the response contradict itself or conflict with prior conversation context?

### Automatic Rejection Thresholds

Define minimum quality scores below which the system does not display the response. Instead, it falls back to a safe response: "I wasn't able to generate a reliable answer. Let me try a different approach" or routes to a human agent.

### Human-in-the-Loop Review Triggers

For high-stakes domains, define conditions that trigger human review before the response reaches the user:

- Confidence score below threshold.
- Response touches a sensitive topic (medical, legal, financial).
- User has flagged previous responses in the same session.
- Self-consistency check reveals significant disagreement across samples.

---

## 8. arXiv Six Best-Practice Clusters

Drawing from the December 2024 survey on hallucination mitigation in large language models (arXiv:2412.xxxxx series), six clusters of best practice emerge.

### Calibration

Ensure that the model's expressed confidence aligns with its actual accuracy. Techniques include temperature scaling, Platt scaling on logits, verbalized uncertainty training, and reward modeling that penalizes overconfident errors. UX implication: confidence indicators are only useful if the underlying scores are well-calibrated.

### Attribution

Ground every claim in a traceable source. Techniques include retrieval-augmented generation, post-hoc citation attachment, and training with attribution supervision. UX implication: design citation UX that makes sources visible, accessible, and verifiable with minimal friction.

### Abstention

Train and prompt models to decline answering when they lack sufficient knowledge. Techniques include abstention training (reward models that value "I don't know" over confabulation), knowledge boundary detection, and calibrated thresholds for response generation. UX implication: design "I don't know" states that are helpful rather than frustrating — always provide an alternative path.

### Retrieval Augmentation

Ground generation in retrieved evidence at inference time. Techniques include dense passage retrieval, hybrid sparse-dense retrieval, multi-hop reasoning over retrieved documents, and retrieved-document reranking. UX implication: show users what was retrieved, not just what was generated. Transparency about the retrieval process builds trust.

### Human Oversight

Keep humans in the loop for high-stakes decisions. Techniques include human-in-the-loop review workflows, escalation triggers, and user-driven verification. UX implication: design escalation paths that feel natural rather than bureaucratic. Make it easy for users to request human review.

### Iterative Refinement

Allow both the system and the user to refine outputs through multiple rounds. Techniques include self-critique and revision, user feedback incorporation, and chain-of-verification prompting. UX implication: design conversational interfaces that encourage refinement ("Would you like me to verify this further?" or "Here is a revised answer based on additional sources").

---

## 9. CHI 2025 AI Literacy

Research presented at CHI 2025 on AI literacy and user understanding of LLM limitations identifies several key design implications.

### Mental Model Alignment

Users form mental models of AI capability that are often miscalibrated. Common misconceptions include believing the model "knows" rather than "generates," assuming recent events are included in training data, and treating high fluency as evidence of accuracy. Interfaces should actively correct these misconceptions.

**Design strategies for mental model alignment:**

- **Onboarding.** During first use, explicitly explain what the model can and cannot do. Use concrete examples of failure modes.
- **Contextual reminders.** When the model generates content in high-risk domains, display brief reminders: "AI-generated content may contain errors. Verify important information."
- **Capability boundaries.** When users ask about topics outside the model's reliable capability, state this explicitly rather than attempting an answer.

### Trust Calibration

Trust calibration refers to aligning user trust levels with actual system reliability. Overtrust is as dangerous as undertrust — overtrusting users act on hallucinated information, while undertrusting users fail to benefit from accurate AI assistance.

**Design strategies for trust calibration:**

- **Progressive trust building.** Start with low-stakes interactions where users can verify accuracy. As users build calibrated trust, the system can take on higher-stakes tasks.
- **Accuracy track record.** Show users the system's accuracy statistics for their specific use case, not just global benchmarks.
- **Failure exposure.** Deliberately surface past errors (anonymized) to prevent overconfidence. "In 4% of similar queries, our system provided incorrect information."

### Diverse Literacy Levels

Users vary dramatically in their understanding of AI. Interfaces must serve both AI-savvy users who want granular confidence data and AI-novice users who need simpler trust signals.

- **Layered disclosure.** Show a simple trust indicator by default. Offer a "details" expansion for users who want to see confidence scores, source citations, and verification status.
- **Adaptive explanations.** Track user engagement with transparency features and adjust detail levels over time.

---

## 10. Implementation Patterns

### Confidence Badge Component

```tsx
type ConfidenceLevel = 'high' | 'medium' | 'low';

interface ConfidenceBadgeProps {
  level: ConfidenceLevel;
  score?: number;        // 0-1 numeric score for tooltip detail
  showDetails?: boolean; // allow expansion to show reasoning
}

function ConfidenceBadge({ level, score, showDetails }: ConfidenceBadgeProps) {
  const config = {
    high: {
      label: 'Verified',
      className: 'badge-solid',
      ariaLabel: `High confidence${score ? `: ${Math.round(score * 100)}%` : ''}`
    },
    medium: {
      label: 'Likely',
      className: 'badge-partial',
      ariaLabel: `Medium confidence${score ? `: ${Math.round(score * 100)}%` : ''}`
    },
    low: {
      label: 'Unverified',
      className: 'badge-outline',
      ariaLabel: `Low confidence${score ? `: ${Math.round(score * 100)}%` : ''}`
    }
  };

  const { label, className, ariaLabel } = config[level];

  return (
    <span
      className={`confidence-badge ${className}`}
      role="status"
      aria-label={ariaLabel}
      title={score ? `Confidence: ${Math.round(score * 100)}%` : undefined}
    >
      {label}
    </span>
  );
}
```

### Inline Citation Link Component

```tsx
interface CitationSource {
  id: string;
  title: string;
  url: string;
  excerpt: string;
  publishedDate?: string;
  matchScore: number;     // How well this source supports the claim (0-1)
}

interface InlineCitationProps {
  index: number;
  source: CitationSource;
}

function InlineCitation({ index, source }: InlineCitationProps) {
  const [showPreview, setShowPreview] = useState(false);

  return (
    <span className="citation-wrapper">
      <button
        className="citation-marker"
        aria-label={`Citation ${index}: ${source.title}`}
        onMouseEnter={() => setShowPreview(true)}
        onMouseLeave={() => setShowPreview(false)}
        onClick={() => setShowPreview(!showPreview)}
      >
        [{index}]
      </button>

      {showPreview && (
        <div
          className="citation-preview"
          role="tooltip"
          aria-live="polite"
        >
          <p className="citation-title">{source.title}</p>
          {source.publishedDate && (
            <time className="citation-date">{source.publishedDate}</time>
          )}
          <blockquote className="citation-excerpt">
            {source.excerpt}
          </blockquote>
          <div className="citation-meta">
            <ConfidenceBadge
              level={source.matchScore > 0.8 ? 'high' : source.matchScore > 0.5 ? 'medium' : 'low'}
              score={source.matchScore}
            />
            <a
              href={source.url}
              target="_blank"
              rel="noopener noreferrer"
              className="citation-link"
            >
              Open source
            </a>
          </div>
        </div>
      )}
    </span>
  );
}
```

### Verification Flow Component

```tsx
interface VerificationResult {
  claim: string;
  status: 'supported' | 'disputed' | 'unverifiable';
  sources: CitationSource[];
  explanation: string;
}

interface VerificationFlowProps {
  claim: string;
  onVerify: (claim: string) => Promise<VerificationResult>;
}

function VerificationFlow({ claim, onVerify }: VerificationFlowProps) {
  const [state, setState] = useState<'idle' | 'loading' | 'complete'>('idle');
  const [result, setResult] = useState<VerificationResult | null>(null);

  async function handleVerify() {
    setState('loading');
    try {
      const verification = await onVerify(claim);
      setResult(verification);
      setState('complete');
    } catch {
      setState('idle');
    }
  }

  if (state === 'idle') {
    return (
      <button
        className="verify-button"
        onClick={handleVerify}
        aria-label={`Verify claim: ${claim.substring(0, 50)}...`}
      >
        Verify this
      </button>
    );
  }

  if (state === 'loading') {
    return (
      <span className="verify-loading" role="status" aria-live="polite">
        Checking sources...
      </span>
    );
  }

  const statusConfig = {
    supported: { label: 'Supported by sources', className: 'status-supported' },
    disputed: { label: 'Conflicting information found', className: 'status-disputed' },
    unverifiable: { label: 'Could not verify', className: 'status-unverifiable' }
  };

  const { label, className } = statusConfig[result!.status];

  return (
    <div className={`verification-result ${className}`} role="region" aria-label="Verification result">
      <p className="verification-status">{label}</p>
      <p className="verification-explanation">{result!.explanation}</p>
      {result!.sources.length > 0 && (
        <ul className="verification-sources" aria-label="Supporting sources">
          {result!.sources.map((source, i) => (
            <li key={source.id}>
              <a href={source.url} target="_blank" rel="noopener noreferrer">
                {source.title}
              </a>
              <ConfidenceBadge
                level={source.matchScore > 0.8 ? 'high' : source.matchScore > 0.5 ? 'medium' : 'low'}
                score={source.matchScore}
              />
            </li>
          ))}
        </ul>
      )}
    </div>
  );
}
```

### Error Feedback Component

```tsx
type ErrorCategory =
  | 'factually-incorrect'
  | 'outdated'
  | 'irrelevant'
  | 'harmful'
  | 'citation-error'
  | 'other';

interface ErrorFeedbackProps {
  responseId: string;
  onSubmit: (feedback: {
    responseId: string;
    category: ErrorCategory;
    correction?: string;
  }) => Promise<void>;
}

function ErrorFeedback({ responseId, onSubmit }: ErrorFeedbackProps) {
  const [isOpen, setIsOpen] = useState(false);
  const [category, setCategory] = useState<ErrorCategory | null>(null);
  const [correction, setCorrection] = useState('');
  const [submitted, setSubmitted] = useState(false);

  async function handleSubmit() {
    if (!category) return;
    await onSubmit({
      responseId,
      category,
      correction: correction || undefined
    });
    setSubmitted(true);
  }

  if (submitted) {
    return (
      <div className="feedback-thanks" role="status">
        Thank you for your feedback. It helps improve our system.
      </div>
    );
  }

  if (!isOpen) {
    return (
      <button
        className="feedback-trigger"
        onClick={() => setIsOpen(true)}
        aria-label="Report a problem with this response"
      >
        Report issue
      </button>
    );
  }

  const categories: { value: ErrorCategory; label: string }[] = [
    { value: 'factually-incorrect', label: 'Factually incorrect' },
    { value: 'outdated', label: 'Outdated information' },
    { value: 'irrelevant', label: 'Irrelevant to my question' },
    { value: 'harmful', label: 'Harmful or offensive' },
    { value: 'citation-error', label: 'Citation error' },
    { value: 'other', label: 'Other issue' }
  ];

  return (
    <div className="feedback-form" role="form" aria-label="Error feedback">
      <fieldset>
        <legend>What was wrong with this response?</legend>
        {categories.map(({ value, label }) => (
          <label key={value} className="feedback-option">
            <input
              type="radio"
              name="error-category"
              value={value}
              checked={category === value}
              onChange={() => setCategory(value)}
            />
            {label}
          </label>
        ))}
      </fieldset>

      <label className="feedback-correction-label">
        Correct answer (optional):
        <textarea
          className="feedback-correction"
          value={correction}
          onChange={(e) => setCorrection(e.target.value)}
          rows={3}
          placeholder="If you know the correct information, share it here..."
        />
      </label>

      <div className="feedback-actions">
        <button onClick={() => setIsOpen(false)}>Cancel</button>
        <button
          onClick={handleSubmit}
          disabled={!category}
          className="feedback-submit"
        >
          Submit feedback
        </button>
      </div>
    </div>
  );
}
```

---

## Summary

Hallucination guardrails are not a single feature but a layered defense system. The taxonomy of hallucination types informs where guardrails are needed. Detection patterns provide the technical foundation. Confidence indicators, verification UX, and honest uncertainty expression translate technical signals into user-facing trust calibration. Error reporting creates a feedback loop for continuous improvement. Quality gates prevent low-quality output from reaching users. And grounding in research — from arXiv surveys on mitigation clusters to CHI 2025 work on AI literacy — ensures that design decisions are evidence-based rather than intuitive. The implementation patterns provided here are starting points; adapt them to your specific framework, design system, and user research findings. The goal is not to eliminate hallucination entirely (which remains an open research problem) but to design interfaces that make uncertainty visible, verification easy, and trust appropriately calibrated.
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