Claude Code 대화 기록 분석으로 스킬 자동화 기회 찾기

1
---
2
name: suggest-automation
3
description: Claude Code 대화 기록을 분석하여 반복 패턴을 찾고 스킬 자동화 기회를 추천한다.
4
---
5

6
# Suggest Automation
7

8
Claude Code 대화 기록(~/.claude/)을 분석하여 반복되는 작업 패턴을 찾고, 스킬로 자동화할 기회를 추천한다.
9

10
## Overview
11

12
Claude가 직접 대화 기록을 읽고 분석한다. **자연어 이해**로 프롬프트 의도를 파악하고, 맥락을 고려한 패턴을 발견한다.
13

14
## Workflow
15

16
### Step 1: 세션 데이터 로드
17

18
scripts/analyze-sequences.py 스크립트로 세션 데이터를 추출한다.
19
~/.claude/projects/에서 세션별 프롬프트를 추출하여 분석 가능한 형태로 출력한다.
20

21
### Step 2: 프롬프트 의도 분류 (Claude)
22

23
추출된 프롬프트들을 **Claude가 직접 분류**한다.
24

25
**분류 카테고리:**
26

27
| 카테고리 | 의미 | 예시 |
28
|---------|------|------|
29
| start | 새 작업 시작 | "로그인 기능 만들어줘" |
30
| modify | 기존 코드 수정 | "버튼 색 바꿔줘" |
31
| verify | 결과 검증 | "빌드 돌려봐" |
32
| fix | 문제 해결 | "에러 왜 나지?" |
33
| continue | 작업 계속 | "응", "ok" |
34
| commit | 저장/배포 | "커밋해줘" |
35
| question | 질문 | "이거 뭐야?" |
36
| feedback | 부정적 피드백 | "다시 해줘" |
37

38
**분류 시 고려사항:**
39
- 표면적 키워드가 아닌 **실제 의도** 파악
40
- 이전/이후 프롬프트와의 관계 고려
41

42
### Step 3: 시퀀스 패턴 분석 (Claude)
43

44
분류된 프롬프트들의 **시퀀스 패턴**을 분석한다.
45

46
**분석 항목:**
47
- 세션 내 프롬프트 흐름 (예: start → verify → fix → verify)
48
- 반복되는 시퀀스 패턴
49
- 자주 실패/재시도하는 요청
50
- 복잡한 멀티스텝 작업
51

52
### Step 4: 스킬 기회 판단
53

54
**스킬로 만들 가치가 있는 조건:**
55

56
| 조건 | 설명 |
57
|------|------|
58
| 컨텍스트 필요 | 프로젝트/상황 파악이 필요 |
59
| 멀티스텝 | 여러 단계가 연속으로 필요 |
60
| 실패 빈도 높음 | 자주 재시도하는 패턴 |
61
| 검증 루프 | 확인→수정→확인 반복 |
62

63
**스킬로 만들 가치가 없는 것:**
64
- 단순 명령어 ("커밋해줘")
65
- 일회성 요청
66
- 프롬프트 한 줄로 충분한 작업
67

68
### Step 5: 추천 보고
69

70
분석 결과를 다음 형식으로 보고한다:
71

72
📊 분석 결과 요약
73
총 대화: N개 | 세션: M개 | 반복 패턴: K개
74

75
🔥 높은 가치 (즉시 스킬화 추천)
76
1. [스킬명] - [근거] (N회 반복)
77

78
⚡ 중간 가치 (선택적 스킬화)
79
1. [스킬명] - [근거]
80

81
🛡️ 가드레일 필요 (실패 방지)
82
1. [패턴] - [실패 횟수]회 재시도 발생
83

84
### Step 6: 스킬 생성
85

86
사용자가 스킬 생성을 요청하면, **skill-creator 스킬을 사용**하여 정식 스킬 구조로 생성한다.
87

88
## References
89

90
스킬 추천 기준에 대한 상세 문서는 references/skill-patterns.md 참조.

1
#!/usr/bin/env python3
2
"""
3
Claude Code 세션 시퀀스 분석
4
프롬프트 간 연관관계를 분석하여 고차원 워크플로우 패턴 추출
5
"""
6

7
import json
8
import re
9
from collections import Counter, defaultdict
10
from pathlib import Path
11
import argparse
12

13

14
def load_sessions(projects_dir: Path, project_filter: str = None) -> list[dict]:
15
    """세션별 대화 로드"""
16
    sessions = []
17

18
    # 시스템/내부 메시지 필터링 패턴
19
    system_patterns = [
20
        r'^<(command|local-command|bash|tool)',
21
        r'^Caveat:',
22
        r'^This (session|slash)',
23
        r'^\[Request interrupted',
24
        r'^<shell-id>',
25
        r'^/compact',
26
        r'^/exit',
27
        r'^/clear',
28
        r'^/mcp',
29
    ]
30

31
    for project_dir in projects_dir.iterdir():
32
        if not project_dir.is_dir():
33
            continue
34
        if project_filter and project_filter not in project_dir.name:
35
            continue
36

37
        for session_file in project_dir.glob("*.jsonl"):
38
            if session_file.name.startswith("agent-"):
39
                continue
40

41
            session_data = {
42
                'project': project_dir.name,
43
                'session_id': session_file.stem,
44
                'prompts': [],
45
            }
46

47
            try:
48
                with open(session_file, 'r', encoding='utf-8') as f:
49
                    for line in f:
50
                        try:
51
                            entry = json.loads(line.strip())
52
                            if entry.get('type') == 'user' or 'display' in entry:
53
                                text = entry.get('message', {}).get('content', '') or entry.get('display', '')
54
                                if isinstance(text, list):
55
                                    text = ' '.join([t.get('text', '') for t in text if isinstance(t, dict)])
56

57
                                if text and len(text) > 2:
58
                                    is_system = False
59
                                    for pattern in system_patterns:
60
                                        if re.match(pattern, text):
61
                                            is_system = True
62
                                            break
63
                                    if not is_system:
64
                                        session_data['prompts'].append({
65
                                            'text': text[:500],
66
                                            'timestamp': entry.get('timestamp'),
67
                                        })
68
                        except json.JSONDecodeError:
69
                            continue
70
            except Exception:
71
                continue
72

73
            if len(session_data['prompts']) >= 3:
74
                sessions.append(session_data)
75

76
    return sessions
77

78

79
def extract_sequences(sessions: list[dict], min_length: int = 3) -> list[dict]:
80
    """세션에서 의미있는 시퀀스 추출"""
81
    sequences = []
82

83
    for session in sessions:
84
        if len(session['prompts']) < min_length:
85
            continue
86

87
        # 시퀀스 패턴 추출 (연속 3-5개)
88
        for i in range(len(session['prompts']) - 2):
89
            seq_len = min(5, len(session['prompts']) - i)
90
            sequence = session['prompts'][i:i + seq_len]
91

92
            sequences.append({
93
                'project': session['project'],
94
                'prompts': [s['text'][:100] for s in sequence],
95
            })
96

97
    return sequences
98

99

100
def find_retry_patterns(sessions: list[dict]) -> list[dict]:
101
    """실패 → 재시도 패턴 찾기"""
102
    retry_patterns = []
103

104
    for session in sessions:
105
        prompts = session['prompts']
106

107
        for i in range(len(prompts) - 1):
108
            text = prompts[i]['text'].lower()
109

110
            failure_keywords = ['안됨', '안돼', '에러', '오류', '별로', '다시', '잘못',
111
                              'error', 'fail', 'wrong', 'again', 'not working']
112

113
            if any(kw in text for kw in failure_keywords):
114
                retry_patterns.append({
115
                    'trigger': prompts[i]['text'][:100],
116
                    'project': session['project'],
117
                })
118

119
    return retry_patterns
120

121

122
def main():
123
    parser = argparse.ArgumentParser(description='Claude Code 세션 시퀀스 분석')
124
    parser.add_argument('--project', type=str, help='분석할 프로젝트 필터')
125
    parser.add_argument('--projects-dir', type=str,
126
                       default=str(Path.home() / '.claude' / 'projects'))
127
    args = parser.parse_args()
128

129
    projects_dir = Path(args.projects_dir)
130
    if not projects_dir.exists():
131
        print(f"Error: {projects_dir} not found")
132
        return
133

134
    print("세션 로딩 중...", flush=True)
135
    sessions = load_sessions(projects_dir, args.project)
136
    print(f"  → {len(sessions)}개 세션 로드됨")
137

138
    print("시퀀스 추출 중...", flush=True)
139
    sequences = extract_sequences(sessions)
140
    print(f"  → {len(sequences)}개 시퀀스 추출됨")
141

142
    print("실패 패턴 분석 중...", flush=True)
143
    retries = find_retry_patterns(sessions)
144
    print(f"  → {len(retries)}개 재시도 패턴 발견됨")
145

146

147
if __name__ == '__main__':
148
    main()

1
# 스킬 추천 패턴 가이드
2

3
## 스킬로 만들 가치가 있는 패턴
4

5
### 1. 워크플로우 시퀀스 패턴
6

7
| 시퀀스 | 의미 | 자동화 기회 |
8
|--------|------|------------|
9
| verify → work → verify | 검증 루프 | 자동 검증 스킬 |
10
| start → start → verify | 연속 작업 후 확인 | 작업 후 자동 검증 |
11
| fix → verify → fix | 반복 수정 | 가이드라인/가드레일 |
12

13
### 2. 실패 패턴
14

15
| 패턴 | 원인 | 해결 방안 |
16
|------|------|----------|
17
| "안됨", "다시" 반복 | 명확한 지침 부족 | pre-check 스킬 |
18
| 같은 요청 여러 번 | 결과 불만족 | 검증 단계 추가 |
19

20
## 스킬 우선순위 결정 기준
21

22
### 높은 가치 (우선 구현)
23

24
1. **빈도 × 복잡도** 높은 것
25
2. **실패 비용** 높은 것
26
3. **컨텍스트 의존도** 높은 것
27

28
### 낮은 가치 (구현 불필요)
29

30
1. 프롬프트 한 줄로 충분한 작업
31
2. 일회성 또는 매우 드문 작업
32
3. 이미 빌트인 명령어로 해결 가능한 것
33

34
## 스킬 설계 원칙
35

36
### Progressive Disclosure
37

38
description (항상 로드) → SKILL.md (트리거 시) → references/ (필요 시)
39

40
- description: ~100 단어
41
- SKILL.md: <5000 단어
42
- references/: 제한 없음
43

44
### 트리거 조건 명확화
45

46
description에 포함해야 할 것:
47
- 어떤 요청에 반응하는지
48
- 사용자가 말할 수 있는 구체적 문구