---
id: wiki-2026-0508-human-centered-ai-hcai
title: Human-Centered AI (HCAI)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [HCAI, human-centered AI, Shneiderman, augmented intelligence, AI-assisted, copilot pattern]
duplicate_of: none
source_trust_level: A
confidence_score: 0.94
verification_status: applied
tags: [ai, hcai, hci, ux, augmented-intelligence, copilot]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: AI / UX
  applicable_to: [Product, AI Design, UX]
---

# Human-Centered AI (HCAI)

## 매 한 줄
> **"매 AI 가 humans 의 replace 의 X — 매 humans 의 augment"**. Shneiderman 2022. 매 high human control + high computer automation 의 동시. 매 modern: 매 Copilot, Cursor, Notion AI 의 design pattern. 매 vs autonomous AI.

## 매 핵심

### 매 framework (Shneiderman 2D)
- 매 X-axis: human control (low → high).
- 매 Y-axis: automation (low → high).
- **HCAI** = 매 right-top quadrant: 매 high control + high automation.

### 매 4 modes (Endsley)
- **Manual**.
- **Decision support**.
- **Consensual** (AI suggests, human approves).
- **Monitored automation**.
- **Full automation**.

### 매 응용
1. **Copilot** (code).
2. **Cursor / Continue** (IDE).
3. **Notion AI** (writing).
4. **Medical AI** (clinician support).
5. **Photoshop generative fill**.
6. **CAD AI tools**.

### 매 design principles
- **Reliable** (high reliability + safety).
- **Safe** (graceful degradation).
- **Trustworthy** (explainable + auditable).
- **Transparent** (about AI involvement).
- **Reversible** (undo).
- **Auditable** (log decisions).

## 💻 패턴

### Suggestion + accept (Copilot pattern)
```typescript
function aiSuggest(context: Context): Suggestion[] {
  const candidates = llm.generate(context, n=3);
  return candidates.map(c => ({
    text: c.text,
    confidence: c.confidence,
    explanation: c.explanation,
  }));
}

// 매 UI: 매 ghost text + Tab 의 accept, Esc 의 reject
```

### Confidence-aware UX
```typescript
function renderSuggestion(s: Suggestion) {
  if (s.confidence > 0.9) return <strong>{s.text}</strong>;  // 매 confident
  if (s.confidence > 0.7) return <span>{s.text}</span>;
  return <span style={{opacity: 0.5}}>{s.text}? <small>(uncertain)</small></span>;
}
```

### Explainable suggestion
```python
def llm_suggest_with_reason(context, llm):
    return llm.generate(f"""
{context}

Output:
- suggestion: <code or text>
- reason: <why this — 1 sentence>
- confidence: <0-1>
- alternatives: <2-3 alternatives>
""")
```

### Reversible action
```typescript
class UndoStack {
  private stack: Action[] = [];
  
  do(action: Action) {
    action.execute();
    this.stack.push(action);
  }
  
  undo() {
    const last = this.stack.pop();
    last?.reverse();
  }
}
```

### AI disclosure (transparency)
```html
<div class="ai-output">
  <p>{output}</p>
  <small class="ai-disclosure">Generated with AI. Verify before using.</small>
</div>
```

### Audit log
```python
def log_ai_decision(input, output, model_version, user_decision):
    db.audit.insert({
        'timestamp': now(),
        'user_id': current_user.id,
        'model': model_version,
        'input_hash': hash(input),
        'output': output,
        'user_action': user_decision,  # 매 accepted | modified | rejected
    })
```

### Graceful degradation
```python
def feature_with_ai_fallback(input):
    try:
        return ai_enhance(input)
    except (RateLimitError, ServiceDown):
        return manual_default(input)
```

### Calibrated confidence display
```javascript
function confidenceLabel(score) {
  if (score > 0.95) return { label: 'High confidence', color: 'green' };
  if (score > 0.8) return { label: 'Likely', color: 'blue' };
  if (score > 0.6) return { label: 'Possible', color: 'orange' };
  return { label: 'Uncertain — verify', color: 'red' };
}
```

### Diff-based AI edit (review)
```typescript
// 매 LLM proposes change → user sees diff → approves/rejects
function showDiffForApproval(original: string, proposed: string) {
  return {
    diff: computeDiff(original, proposed),
    actions: ['Accept', 'Reject', 'Edit'],
  };
}
```

### Per-user adaptation
```python
class PersonalizedAI:
    def __init__(self, user):
        self.user = user
        self.preferences = load_preferences(user)
    
    def suggest(self, context):
        base = llm.generate(context)
        return adapt_to_style(base, self.preferences.style)
    
    def feedback(self, suggestion, accepted):
        self.preferences.update(suggestion, accepted)
```

### Multi-step approval (agent)
```python
def hcai_agent(goal, tools):
    plan = llm.plan(goal)
    for step in plan:
        approval = ask_user(f'Approve: {step}?')
        if not approval: return 'cancelled'
        result = execute(step, tools)
        update_user(result)
```

### AI vs human comparison (audit)
```python
def compare_ai_vs_human(items, ai_outputs, human_outputs):
    return {
        'agreement': sum(1 for a, h in zip(ai_outputs, human_outputs) if a == h) / len(items),
        'ai_overrides_kept': count(item.ai_overridden_by_human for item in items),
    }
```

### Critique mode
```python
def ai_critique(user_work, llm):
    return llm.generate(f"""Critique constructively. Don't rewrite.

User work:
{user_work}

Output:
- strengths: ...
- weaknesses: ...
- specific suggestions: ...""")
```

## 매 결정 기준
| 상황 | Mode |
|---|---|
| Code editor | Suggestion + accept |
| Medical diagnosis | Decision support |
| Writing | Critique + suggest |
| Auto-routing | Monitored automation |
| High-stakes | Full HITL |
| Low-stakes ambient | Background AI |

**기본값**: 매 high control + high automation + 매 reversible + 매 explainable + 매 disclosure + 매 audit log.

## 🔗 Graph
- 부모: [[AI]] · [[Human Computer Interaction]]
- 변형: [[Augmented-Intelligence]]
- 응용: [[Human-in-the-loop (HITL)]] · [[AI_Safety_and_Alignment|Constitutional-AI]]
- Adjacent: [[Ethics & AI]] · [[Emotional-AI (Affective Computing)|Empathy-in-AI]] · [[Excessive Agency]]

## 🤖 LLM 활용
**언제**: 매 모든 AI product. 매 productivity. 매 medical.
**언제 X**: 매 fully autonomous infra.

## ❌ 안티패턴
- **AI replaces human**: 매 trust loss.
- **Hide AI involvement**: 매 transparency 의 violate.
- **No undo**: 매 destructive.
- **Confidence theater**: 매 fake high score.
- **Auto-accept default**: 매 human disempower.

## 🧪 검증 / 중복
- Verified (Shneiderman HCAI 2022, Endsley levels of automation).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Shneiderman + 매 suggest / disclosure / undo / audit code |
