해당 방법 주의점
클로드 코드가 토큰 먹는 하마가 된다. 그래서 이제 이렇게는 안쓰지만 이런식의 방법도 한번 트라이 해봤다 느낌으로 보면 될거같다.
문제 인식
클로드 코드를 사용해서 개발 생산성을 높이기 위해 이것저것 처리하다 보니 항상 느끼는건 클로드 코드로 코드를 생성하는것 자체는 굉장히 빠르지만 문제는 일관되지 않은 컨벤션 및 자꾸 뭔가 이상한 로직들 그리고 우회하는 코드들이 많다라는 점이다.
그래서 계속해서 사용하다 보면 퀄리티 자체를 기대하면 안되는데 아무리 총 해야할 작업들을 잘게잘게 쪼개서 컨텍스트를 유지한다 하더라도 이게 잘 안되더라.
프롬프트가 아니라 프로세스 (Ⅱ): 컨텍스트 드리프트를 막는 다섯 가지 벽
지난 글에서 노션→지라→LLM→PR의 파이프라인을 만들었다.태스크를 잘게 쪼개고, 한 세션에 하나씩만 던지는 구조.그런데 여전히 구멍이 있었다.클로드는 똑똑하지만 금붕어 급 기억력을 가졌
ryu-qqq.tistory.com
내가 예전에 작성한 글인데 이것도 나름 제대로 작동한다고 생각했는데 결과물은 엉망이였다.
해결 방안: 코딩 컨벤션 주입
그래서 아예 코딩 컨벤션에 대해 엄청 빡세게 작성하고 그걸 주입하면 어떨까하고
그거에 대한 코딩 컨벤션을 엄청 디테일하고 자세하게 적었다.
실제로 양이 엄청 많고 총 01~08까지 구성되어있다.
문제는
이 방대한 양의 문서를 클로드 세션에 넣으면 엄청난 토큰이 주입되는것이 문제다.
해결책
그래서 각 문서들을 기반으로 rules를 json화 했다. 아래와 같이 말이다.
아래와 같이 말이다.
{
"id": "adapter-rest-api-layer-controller-design-01_restful-api-design",
"sourceFile": "/Users/sangwon-ryu/fileflow/docs/coding_convention/01-adapter-rest-api-layer/controller-design/01_restful-api-design.md",
"metadata": {
"keywords": {
"primary": ["restful", "api", "design"],
"secondary": ["restful", "api", "설계", "원칙"],
"anti": []
},
"layer": "adapter-rest",
"priority": "high",
"tokenEstimate": 3538
},
"rules": {
"prohibited": [
"❌ 리소스가 아닌 행위(동사)에 집중",
"❌ HTTP 메서드의 의미를 무시 (모두 POST 또는 GET으로 처리)",
"❌ RESTful 클라이언트 도구와 호환성 저하",
"❌ API 설계 일관성 부족",
"❌ 확장성 및 유지보수성 저하"
],
"allowed": []
},
"documentation": {
"path": "docs/coding_convention/01-adapter-rest-api-layer/controller-design/01_restful-api-design.md",
"summary": "Auto-generated from 01_restful-api-design.md"
}
}
중앙 색인 시스템
그리고 저 json들을 index.json라는 곳에 모아두고 코딩 규칙을 키워드와 레이어로 빠르게 찾을 수 있는 중앙 색인 파일을 만들었다.
아래와 같이 말이다
{
"version": "1.0.0",
"buildDate": "2025-10-22T06:15:57.375207Z",
"totalRules": 96,
"keywordIndex": {
"restful": [
"adapter-rest-api-layer-controller-design-01_restful-api-design"
],
"api": [
"adapter-rest-api-layer-controller-design-01_restful-api-design",
"adapter-rest-api-layer-dto-patterns-01_api-request-dto",
"adapter-rest-api-layer-dto-patterns-02_api-response-dto",
"adapter-rest-api-layer-mapper-patterns-01_api-to-usecase-mapper",
"testing-integration-testing-02_api-integration-tests"
],
"design": [
"adapter-rest-api-layer-controller-design-01_restful-api-design",
"domain-layer-aggregate-design-02_aggregate-root-design",
"enterprise-patterns-event-driven-04_multi-module-event-design",
"error-handling-02_domain-exception-design"
],
.....
색인 방식
두가지가 있는데
1. keywordIndex (키워드 → 규칙)
- 용도: 사용자 입력에서 키워드 감지 후 관련 규칙 찾기
- 예시: "aggregate entity 작성" → aggregate, entity 키워드 매칭 → domain layer 규칙 반환
2. layerIndex (레이어 → 규칙)
- 용도: 특정 레이어의 모든 규칙 한 번에 로드
- 예시: "domain" 레이어 → domain 관련 12개 규칙 모두 반환
로 구성되어 있다.
그래서 일부러 헥사고날 아키텍쳐를 택했다(레퍼런스도 많고 규칙으로 정하기 용이하다 판단)
클로드 코드 세션 훅 설정
그리고 저걸 클로드 코드 세션 훅에 python 코드를 사용하여 동적으로 코딩 컨벤션을 주입하도록 했다.
아래는 hooks.json의 일부이다.
"AfterToolUse": [
{
"matcher": "Write|Edit|MultiEdit",
"hooks": [
{
"type": "command",
"command": "bash .claude/hooks/after-tool-use.sh {{toolName}} {{filePath}}"
}
]
}
],
"UserPromptSubmit": [
{
"hooks": [
{
"type": "command",
"command": "bash .claude/hooks/user-prompt-submit.sh"
}
]
}
]
세션 타이밍에 대해 헷갈리면 아래 글을 확인해보자
더보기
AfterToolUse
- Claude가 도구(tool)를 사용한 직후에 발생
- 예를 들어:
- 파일을 읽거나 (view, get_file_text_by_path)
- 파일을 수정하거나 (str_replace, create_file)
- 코드를 실행하거나 (bash_tool, execute_terminal_command)
- 파일을 검색하는 등 (search_in_files_content)
타이밍 차이:
1. 당신: "config.json 파일 열어줘"
2. → UserPromptSubmit 이벤트 발생
3. Claude: view 도구 사용
4. → AfterToolUse 이벤트 발생
5. Claude: 파일 내용을 보여주며 응답
이제 흐름에 대해 살펴보면
사용자 입력
↓
UserPromptSubmit Hook에서 user-prompt-submit.sh로 키워드 감지
↓
index.json (Layer → Rule IDs 매핑)
↓
inject-rules.py (JSON 규칙 로드 및 주입)
↓
Claude (규칙 준수 코드 생성)
↓
AfterToolUse Hook (Write 도구 사용 감지)
↓
validation-helper.py (Cache 기반 검증)
↓
index.json (Layer → Rule IDs 다시 조회)
이고 자세히 살펴보자
📝 Part 1: UserPromptSubmit Hook → index.json
1단계: 사용자 입력 캡처
파일: .claude/hooks/user-prompt-submit.sh
# 입력 읽기 (Claude Code가 stdin으로 전달)
USER_INPUT=$(cat)
# 예시: "/domain Order Aggregate 작성"
핵심: Claude Code는 사용자가 메시지를 제출하면 즉시 이 Hook을 트리거하고, 사용자 입력을 stdin으로 전달
2단계: 키워드 스코어링
목표: 입력에서 키워드를 감지하고 점수 계산
# 키워드 목록 (33개)
KEYWORDS="aggregate entity getter factory usecase controller repository test ..."
CONTEXT_SCORE=0
DETECTED_LAYERS=()
DETECTED_KEYWORDS=()
# Primary Keywords 검색 (30점)
for keyword in $KEYWORDS; do
if echo "$USER_INPUT" | grep -qiE "$keyword"; then
layer=$(get_layer_from_keyword "$keyword")
if [ -n "$layer" ]; then
CONTEXT_SCORE=$((CONTEXT_SCORE + 30))
DETECTED_LAYERS+=("$layer")
DETECTED_KEYWORDS+=("$keyword")
fi
fi
done
```
**예시 실행:**
```
입력: "/domain Order Aggregate 작성"
감지된 키워드:
- "domain" → domain layer (Primary: 30점)
- "aggregate" → domain layer (Primary: 30점)
- "order" → (매칭 안됨)
Total Score: 60점
Detected Layers: ["domain"]
Detected Keywords: ["domain", "aggregate"]3단계: Layer 감지
키워드 → Layer 매핑 함수:
get_layer_from_keyword() {
local keyword="$1"
case "$keyword" in
# Domain layer
aggregate|entity|getter|factory|policy)
echo "domain"
;;
# Application layer
usecase|service|command|query|transaction)
echo "application"
;;
# Adapter-REST layer
controller|endpoint|validation|request|response)
echo "adapter-rest"
;;
# ... 기타
esac
}
결과: aggregate, entity 키워드 → domain layer
4단계: Threshold 체크 (25점)
if [[ $CONTEXT_SCORE -ge 25 ]]; then
# 규칙 주입 실행
python3 .claude/commands/lib/inject-rules.py "$layer"
else
# 스킵
echo "Score too low, skip injection"
fi예시:
- Score: 60점 ≥ 25점 ✅
- Action: inject-rules.py domain 호출
5단계: inject-rules.py 실행
파일: .claude/commands/lib/inject-rules.py
5-1. index.json 로드
def load_index():
"""index.json 로드"""
with open(INDEX_FILE, 'r', encoding='utf-8') as f:
return json.load(f)
index = load_index()index.json 구조:
{
"version": "1.0.0",
"totalRules": 96,
"layerIndex": {
"domain": [
"domain-layer-aggregate-design-01_aggregate-root-pattern",
"domain-layer-law-of-demeter-01_getter-chaining-prohibition",
"domain-layer-package-guide-01_domain-package-structure"
]
...
}
}
5-2. layerIndex 쿼리
def inject_layer_rules(layer: str, priority_filter: str = None):
index = load_index()
# 1. layerIndex에서 domain layer의 rule IDs 추출
rule_ids = index.get("layerIndex", {}).get(layer, [])핵심: index.json의 layerIndex["domain"]을 조회하면 O(1) 해시 룩업으로 domain layer의 모든 rule IDs를 가져온다.
5-3. JSON 규칙 파일 로드
# 2. 각 rule ID로 JSON 파일 로드
rules = []
for rule_id in rule_ids:
rule = load_rule(rule_id) # domain-layer-*.json 로드
if rule:
# Priority 필터링 (optional)
if priority_filter and rule["metadata"]["priority"] != priority_filter:
continue
rules.append(rule)
```
로드되는 파일 예시:
```
.claude/cache/rules/domain-layer-aggregate-design-01_aggregate-root-pattern.json
.claude/cache/rules/domain-layer-law-of-demeter-01_getter-chaining-prohibition.json
... (총 12개)각 JSON 구조:
{
"metadata": {
"id": "domain-layer-aggregate-design-01_aggregate-root-pattern",
"title": "Aggregate Root 패턴",
"layer": "domain",
"priority": "critical"
},
"rules": {
"prohibited": [
"NO Spring Framework imports",
"NO JPA annotations",
"NO Lombok"
],
"allowed": [
"Pure Java only",
"Apache Commons Lang3"
]
},
"documentation": {
"path": "docs/coding_convention/02-domain-layer/...",
"summary": "Aggregate는 트랜잭션 경계"
}
}
5-4. Markdown 변환 및 stdout 출력
# 3. Markdown으로 변환
print("---")
print()
print(f"## 🎯 DOMAIN 레이어 규칙 (자동 주입됨)")
print()
# Critical 규칙
print("### ❌ 금지 규칙 (Zero-Tolerance)")
for rule in critical_rules:
for item in rule["rules"]["prohibited"]:
print(f"- {item}")
# 필수 규칙
print("### ✅ 필수 규칙")
for rule in rules:
for item in rule["rules"]["allowed"]:
print(f"- {item}")
# 참고 문서
print("### 📋 상세 문서")
for rule in rules:
print(f"- [{rule['documentation']['summary']}]({rule['documentation']['path']})")
print("---")출력 예시:
---
## 🎯 DOMAIN 레이어 규칙 (자동 주입됨)
### ❌ 금지 규칙 (Zero-Tolerance)
- NO Spring Framework imports (org.springframework.*)
- NO JPA annotations (@Entity, @Table, @Column)
- NO Lombok (@Data, @Getter, @Setter)
### ✅ 필수 규칙
- Pure Java only
- Immutable value objects (private final)
- Factory methods for object creation
### 📋 상세 문서
- [Aggregate Root 패턴](docs/coding_convention/02-domain-layer/aggregate-design/01_aggregate-root-pattern.md)
- [Law of Demeter](docs/coding_convention/02-domain-layer/law-of-demeter/01_getter-chaining-prohibition.md)
**이 규칙들은 실시간으로 검증됩니다.**
---
핵심: stdout으로 출력된 Markdown은 Claude 컨텍스트에 자동 주입
6단계: Claude가 규칙 준수 코드 생성
Claude는 주입된 규칙을 읽고:
- ❌ Lombok 사용 금지
- ❌ Spring/JPA 어노테이션 금지
- ✅ Pure Java getter/setter 작성
- ✅ Law of Demeter 준수
생성된 코드 예시:
/**
* Order Aggregate
*
* @author Claude
* @since 2025-10-22
*/
public class Order {
private final OrderId orderId;
private final CustomerId customerId;
// Lombok 없이 Pure Java getter
public OrderId getOrderId() {
return orderId;
}
public CustomerId getCustomerId() {
return customerId;
}
// Getter 체이닝 대신 Tell, Don't Ask
public String getCustomerZipCode() {
return customerId.getZipCode(); // ✅ Law of Demeter 준수
}
}
🔍 Part 2: AfterToolUse Hook → index.json
1단계: Write/Edit 도구 사용 감지
파일: .claude/hooks/after-tool-use.sh
# Claude Code가 전달하는 JSON 읽기
TOOL_DATA=$(cat)
# 파일 경로 추출
FILE_PATH=$(echo "$TOOL_DATA" | jq -r '.file_path // empty')
# 예시: FILE_PATH = "domain/src/main/java/.../Order.java"
트리거 시점: Claude가 Write 또는 Edit 도구를 사용한 직후
2단계: Layer 감지 (파일 경로 기반)
LAYER="unknown"
case "$FILE_PATH" in
*domain/*model*)
LAYER="domain"
;;
*adapter/in/web*)
LAYER="adapter-rest"
;;
*adapter/out/persistence*)
LAYER="adapter-persistence"
;;
*application/*)
LAYER="application"
;;
*test/*)
LAYER="testing"
;;
esac
# 결과: LAYER = "domain"3단계: validation-helper.py 호출
VALIDATOR_SCRIPT=".claude/hooks/scripts/validation-helper.py"
if [[ -f "$VALIDATOR_SCRIPT" && "$LAYER" != "unknown" ]]; then
# Python 검증기 실행
python3 "$VALIDATOR_SCRIPT" "$FILE_PATH" "$LAYER"
fi
4단계: validation-helper.py 실행
파일: .claude/hooks/scripts/validation-helper.py
4-1. index.json 로드 (다시!)
class Validator:
def __init__(self):
self.index = self.load_index()
def load_index(self):
with open(INDEX_FILE, 'r', encoding='utf-8') as f:
return json.load(f)4-2. layerIndex 쿼리 (inject-rules.py와 동일)
def validate_file(self, file_path: str, layer: str):
# 1. index.json에서 domain layer의 rule IDs 추출
rule_ids = self.index.get("layerIndex", {}).get(layer, [])
# 2. 각 rule ID로 JSON 파일 로드
for rule_id in rule_ids:
rule = self.load_rule(rule_id)
# 3. 규칙별 검증 실행
result = self.validate_rule(file_path, rule)
self.results.append(result)4-3. 규칙별 검증 실행
def validate_rule(self, file_path: str, rule: dict) -> ValidationResult:
with open(file_path, 'r') as f:
content = f.read()
# 주석/문자열 제거 (false positive 방지)
clean_content = self.remove_comments_and_strings(content, file_path)
# Prohibited 패턴 검증
for prohibited in rule["rules"].get("prohibited", []):
# 예: "NO Lombok" → @Data, @Getter 등 감지
if re.search(r'@(Data|Getter|Setter|Builder)', clean_content):
return ValidationResult(
rule_id=rule["metadata"]["id"],
passed=False,
message=f"Lombok 어노테이션 발견: {prohibited}"
)
# Law of Demeter 검증
if "getter-chaining" in rule["metadata"]["id"]:
# 예: order.getCustomer().getAddress() 패턴 감지
if re.search(r'\.\s*get\w+\(\)\s*\.\s*get\w+\(\)', clean_content):
return ValidationResult(
rule_id=rule["metadata"]["id"],
passed=False,
message="Getter 체이닝 발견 (Law of Demeter 위반)"
)
return ValidationResult(rule_id=rule["metadata"]["id"], passed=True)4-4. 검증 결과 출력
def print_results(self):
if all(r.passed for r in self.results):
print("---")
print("✅ **Validation Passed**")
print(f"파일: `{file_path}`")
print("모든 규칙을 준수합니다!")
print("---")
else:
failed = [r for r in self.results if not r.passed]
print("---")
print("⚠️ **Validation Failed**")
print(f"위반 파일: `{file_path}`")
print()
for result in failed:
print(f"❌ {result.message}")
print(f" 규칙: {result.rule_id}")
print("---")
```
---
트리거 메커니즘으로 전체 워크플로우를 살펴보면
┌─────────────────────────────────────────────────────────────────┐
│ 1. 사용자 입력 │
│ "/domain Order Aggregate 작성" │
└──────────────────────┬──────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ 2. UserPromptSubmit Hook │
│ user-prompt-submit.sh │
│ - 키워드 감지: domain (30), aggregate (30) │
│ - Layer 감지: domain │
│ - Score: 60 ≥ 25 ✅ │
└──────────────────────┬──────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ 3. inject-rules.py 호출 │
│ python3 inject-rules.py domain │
└──────────────────────┬──────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ 4. index.json 조회 │
│ layerIndex["domain"] = [ │
│ "domain-layer-aggregate-design-01_...", │
│ "domain-layer-law-of-demeter-01_...", │
│ ... 12개 rule IDs │
│ ] │
└──────────────────────┬──────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ 5. JSON 규칙 파일 로드 │
│ domain-layer-aggregate-design-01_....json │
│ domain-layer-law-of-demeter-01_....json │
│ ... (12개) │
└──────────────────────┬──────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ 6. Markdown 변환 및 Claude 컨텍스트 주입 │
│ ## 🎯 DOMAIN 레이어 규칙 │
│ ❌ NO Lombok │
│ ❌ NO Getter Chaining │
│ ✅ Pure Java │
└──────────────────────┬──────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ 7. Claude 코드 생성 │
│ Order.java (Lombok 없이, Law of Demeter 준수) │
└──────────────────────┬──────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ 8. AfterToolUse Hook │
│ after-tool-use.sh │
│ - Write 도구 감지 │
│ - 파일 경로: domain/...Order.java │
│ - Layer 감지: domain │
└──────────────────────┬──────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ 9. validation-helper.py 호출 │
│ python3 validation-helper.py Order.java domain │
└──────────────────────┬──────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ 10. index.json 재조회 (같은 프로세스) │
│ layerIndex["domain"] = [...] │
└──────────────────────┬──────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ 11. JSON 규칙 파일 재로드 │
│ domain-layer-*.json (12개) │
└──────────────────────┬──────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ 12. 규칙별 검증 실행 │
│ - Lombok 검증: ✅ Pass │
│ - Getter Chaining 검증: ✅ Pass │
│ - Spring/JPA 검증: ✅ Pass │
└──────────────────────┬──────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ 13. 검증 결과 출력 │
│ ✅ Validation Passed │
│ 파일: Order.java │
│ 모든 규칙을 준수합니다! │
└─────────────────────────────────────────────────────────────────┘
이다.
개선: 슬래시 커맨드 도입
그런데 문제는 내가 프롬프트를 입력하는 단어를 기반으로 레이어를 검증하는 구조라
사람마다 쓰는 방식이 달라질수도 있고 내가 만들었지만 가끔 다르게 이야기해서 프롬프트가 적절한 레이어에 걸리지 않게 되더라.
그래서 슬래시 커맨드를 사용하도록 했다.
문제: 사용자의 표현에 따라 규칙 주입 여부가 달라진다
### Before (키워드 기반)
```
시도 1: "Order 도메인 객체 만들어줘"
→ 규칙 주입 실패 ❌
시도 2: "Order entity 작성해줘"
→ 규칙 주입 성공 ✅
```
### After (Command 기반)
```
사용자: /domain "Order 만들어줘"
↓ (명시적 선언, PreToolUse Hook 트리거 SlashCommand 매처)
시스템: domain layer 확실!
↓
결과: domain 규칙 주입 보장 ✅
커맨드 내용
커맨드 내용 자체는 심플하다. 내가 만든 훅의 레이어에 걸리도록 프롬프트 내에 점수가 높은 단어들을 넣어놨다.
# Domain Layer
/domain "Order Aggregate 작성"
→ Template: "domain entity {{args}}"
→ 확장 결과: "domain entity Order Aggregate 작성"
→ 키워드: domain (30) + entity (30) = 60점 ✅
```
이 커맨드를 명시적으로 사용하게 해서 기존 키워드 기반에서 발생할 수 있는 문제를
```
/domain "Order 만들어줘"
→ 규칙 주입 보장 ✅
커맨드 하나로 규칙 주입을 보장했다.
로깅
또한 이 프롬프트에 대한 결과를 나중에 확인해 보기 위해 로그를 로컬에 남기도록 했다.
{"timestamp": "2025-10-22T15:18:33.413037", "event": "session_start", "session_id": "1761113913-71034", "project": "fileflow", "hook": "user-prompt-submit", "user_command": "domain entity Order 만들어줘"}
{"timestamp": "2025-10-22T15:18:33.685494", "event": "keyword_analysis", "session_id": "1761113913-71034", "context_score": 45, "threshold": 25, "detected_layers": ["domain"], "detected_keywords": ["entity", "domain_context"], "priority_filter": ""}
{"timestamp": "2025-10-22T15:18:33.735975", "event": "decision", "session_id": "1761113913-71034", "action": "cache_injection", "reason": "score_above_threshold"}
{"timestamp": "2025-10-22T15:18:33.793400", "event": "cache_index_loaded", "index_file": "/Users/sangwon-ryu/fileflow/.claude/cache/rules/index.json", "total_rules": 0}
{"timestamp": "2025-10-22T15:18:33.796668", "event": "cache_injection", "layer": "domain", "priority_filter": "all", "total_rules_available": 13, "rules_loaded": 13, "cache_files": ["domain-layer-aggregate-design-01_aggregate-boundaries.json", "domain-layer-aggregate-design-02_aggregate-root-design.json", "domain-layer-aggregate-design-03_consistency-boundaries.json", "domain-layer-law-of-demeter-01_getter-chaining-prohibition.json", "domain-layer-law-of-demeter-02_tell-dont-ask-pattern.json", "domain-layer-law-of-demeter-03_domain-encapsulation.json", "domain-layer-package-guide-01_domain_package_guide.json", "domain-layer-testing-00_testing-support-toolkit.json", "domain-layer-testing-01_aggregate-testing.json", "domain-layer-testing-02_value-object-testing.json", "domain-layer-testing-04_factory-testing.json", "domain-layer-testing-05_domain-event-testing.json", "domain-layer-testing-06_policy-testing.json"], "estimated_tokens": 2120}
...나중에 이 로그를 좀 더 의미있는 로그로 바꾸어 랭퓨즈에 업로드하여 분석하는데 사용할것이다.
프로젝트 활용
이런 템플릿들은 아래 프로젝트에 들어가면 자세히 나와있다.
GitHub - ryu-qqq/claude-spring-standards
Contribute to ryu-qqq/claude-spring-standards development by creating an account on GitHub.
github.com
이걸 활용해서 좀 더 확실하게 팀 단위로 클로드 코드를 통해 팀 컨벤션을 맞출 수 있을거라 기대해본다.
이런식으로 저 깃 프로젝트를 적용해보면 클로드코드가 알아서 내가 만든 슬레시 커맨드 사용을 유도하고 그걸 사용하면 적절한 규칙을 주입받게 해준다!
'AI' 카테고리의 다른 글
| AI로 TDD로 돌리기 — Kent Beck의 CLAUDE를 보고 입맛대로 바꾸기 (0) | 2025.11.15 |
|---|---|
| 프롬프트가 아니라 프로세스 (Ⅲ): 커맨드로 완성하는 자동화 루틴 (0) | 2025.10.05 |
| 프롬프트가 아니라 프로세스 (Ⅱ): 컨텍스트 드리프트를 막는 다섯 가지 벽 (0) | 2025.10.05 |
| 프롬프트가 아니라 프로세스 (Ⅰ): 세션-프루프 개발 루틴 (0) | 2025.10.05 |
| Claude Code - 완벽한 개발 파트너로 만들어보기 (0) | 2025.10.05 |