Ein Tag reicht nicht

Szenario: Du designst einen Geldtransfer-Endpoint. Das ist nicht nur ein API-Problem. Es ist auch Compliance. Und Risk. Und Security. Mit Single-Tag (Lesson 09) könntest du nur einen Bereich adressieren. Mit Multiple Tags: Claude sieht alles auf einmal. Und validiert noch dazu zwischen den Perspektiven.

Phase 1: Der Unterschied zwischen Single und Multiple

Single Tag (Lesson 09):

Design a payment endpoint :compliance

Claude denkt: "Okay, Compliance fokussiert"

Multiple Tags (Lesson 09.2):

Design a payment endpoint :risk :compliance :api

Claude denkt: "Okay, ich brauche Expertise aus Risk, Compliance UND API. Und ich muss das zusammenbringen."

Der zweite ist exponentiell mächtiger.

Phase 2: Advanced Tag-System mit Merging

.claude/tags.json:

{ "risk": { "label": "Risk Assessment", "context": "./docs/risk-assessment.md", "priority": 1 }, "compliance": { "label": "Regulatory Compliance", "context": "./docs/compliance-rules.md", "priority": 2 }, "api": { "label": "API Design", "context": "./docs/api-patterns.md", "priority": 3 }, "security": { "label": "Security", "context": "./docs/security.md", "priority": 4 } }

Was ist neu?

• priority – Tags werden in dieser Reihenfolge geladen. Risk zuerst (am wichtigsten).

Phase 3: Advanced Rewriter für Multiple Tags

.claude/hooks/multi-tag-rewriter.ts:

import { readFileSync } from "fs";

const tags = JSON.parse(readFileSync(".claude/tags.json", "utf-8"));

function findAllTags(prompt: string): string[] { const pattern = /:(\w+)/g; const matches = [...prompt.matchAll(pattern)]; return matches.map(m => m[1]); }

function sortByPriority(tagList: string[]): string[] { return tagList.sort((a, b) => { const priorityA = tags[a]?.priority || 999; const priorityB = tags[b]?.priority || 999; return priorityA - priorityB; }); }

function getContext(tag: string): string { try { const contextFile = tags[tag]?.context; if (!contextFile) return ""; return readFileSync(contextFile, "utf-8"); } catch (error) { console.error("Failed to load", tag, error.message); return ""; } }

function buildMergedContext(tagList: string[]): string { const sortedTags = sortByPriority(tagList); let merged = "# Integrated Guidelines\n\n"; for (const tag of sortedTags) { const label = tags[tag]?.label || tag; const context = getContext(tag); merged += \`## \${label}\n\${context}\n\n\`; } return merged; }

function rewritePrompt(input: any): any { const detectedTags = findAllTags(input.prompt); if (detectedTags.length === 0) { return input; // Kein Tag } const cleanPrompt = input.prompt .replace(/:(\w+)/g, "") .trim(); const mergedContext = buildMergedContext(detectedTags); const enhanced = cleanPrompt + "\n\n" + mergedContext; return { ...input, prompt: enhanced, applied_tags: detectedTags, tag_count: detectedTags.length }; }

export default rewritePrompt;

Was macht das?

1. Findet ALLE Tags im Prompt
2. Sortiert sie nach Priorität (Risk vor Compliance vor API)
3. Lädt alle Context-Dateien
4. Merged sie intelligent in eine Sektion
5. Gibt Claude alles zusammen

Phase 4: System Prompt für Multiple Tags

Das ist wichtig: Claude muss wissen, dass er mehrere Perspektiven hat.

.claude/hooks/system-prompt-builder.ts:

function buildSystemPrompt(tags: string[]): string { if (tags.length === 0) { return "You are a helpful assistant."; } if (tags.length === 1) { return \`You are an expert in \${tags[0]}.\`; } const tagStr = tags.slice(0, -1).join(", ") + " and " + tags[tags.length - 1]; return `` `You are an expert assistant with deep knowledge in: \${tagStr}. When analyzing this request, consider all perspectives. Validate that your recommendations align across all domains. Flag any conflicts or trade-offs between domains.\` ; }

Beispiel mit 3 Tags:

```You are an expert assistant with deep knowledge in: risk, compliance, and api.When analyzing this request, consider all perspectives.Validate that your recommendations align across all domains.Flag any conflicts or trade-offs between domains.```

Claude weiß jetzt: "Ich muss diese 3 Perspektiven zusammenbringen."

Phase 5: Conflict Detection

Wenn Tags konfliktieren, sollte Claude das bemerken.

Beispiel:

Design a fast API endpoint :api :security

• API sagt: "Minimale Validierung für Speed"
• Security sagt: "Maximale Validierung für Safety"

Das ist ein Konflikt.

.claude/hooks/conflict-detector.ts:

function detectConflicts(tags: string[]): string { const conflicts: {[key: string]: string[]} = { "api-vs-security": ["api", "security"], "performance-vs-compliance": ["perf", "compliance"], "speed-vs-safety": ["api", "security"] }; let detected = []; for (const [conflict, conflictTags] of Object.entries(conflicts)) { if (conflictTags.every(t => tags.includes(t))) { detected.push(conflict); } } if (detected.length === 0) { return ""; } ` return ```IMPORTANT: These tags may conflict:\${detected.map(c => "- " + c).join("\n")}Please explicitly address these trade-offs in your answer.`` ;}

Jetzt wenn du :api :security kombinierst:

Claude kriegt:

```IMPORTANT: These tags may conflict:

• api-vs-securityPlease explicitly address these trade-offs in your answer.```

Claude wird explizit Lösungen suchen, die beide Anforderungen erfüllen.

Phase 6: Real-World Beispiel

Vollständiger Flow:

User tippt:

Implement user payment transfer :risk :compliance :api

Hook macht:

1. Findet Tags: risk, compliance, api
2. Sortiert nach Priorität
3. Lädt Risk-Guidelines
4. Lädt Compliance-Guidelines
5. Lädt API-Guidelines
6. Detectet: Keine Konflikte
7. Baut System-Prompt: "Du bist Expert in Risk, Compliance und API..."
8. Merged alle Context
9. Gibt Claude:

```Implement user payment transfer

Risk Assessment

• Transaction velocity limits
• Fraud pattern detection
• [Full risk context]

Regulatory Compliance

• KYC requirements
• AML/CFT procedures
• [Full compliance context]

API Design

• RESTful principles
• Error handling
• [Full API context]

IMPORTANT: Risk and Compliance require careful balance with API performance.Please address these trade-offs.```

Claude antwortet:

Mit einer Lösung, die:

• Risk-Anforderungen erfüllt
• Compliance-Anforderungen erfüllt
• API Best Practices befolgt
• Trade-offs explizit adressiert

Das ist nicht nur ein API-Design. Das ist eine 360°-Lösung.

Phase 7: Logging Multiple Tags

.claude/hooks/multi-tag-logger.ts:

import { appendFileSync } from "fs";

function logMultiTag(prompt: string, tags: string[], merged: string) { const entry = { timestamp: new Date().toISOString(), prompt: prompt.substring(0, 100), tags: tags, tag_count: tags.length, merged_context_size: merged.length, token_estimate: Math.ceil(merged.length / 4) }; appendFileSync(".claude/multi-tag-log.jsonl", JSON.stringify(entry) + "\n");}

Jetzt kannst du analysieren:

• Welche Tag-Kombinationen nutzt du?
• Wie groß ist der generierte Context?
• Wie viele Tokens spart/kostet das?

Phase 8: Intelligentes Merging statt Dupe-Content

Problem: Wenn zwei Context-Dateien Overlaps haben (z.B. beide Compliance erwähnen), wird es redundant.

Lösung: Smart Merging mit Deduplication

.claude/hooks/smart-merger.ts:

function deduplicateContext(contexts: string[]): string { const lines = new Set<string>(); for (const context of contexts) { context.split("\n").forEach(line => { const trimmed = line.trim(); if (trimmed && !trimmed.startsWith("#")) { lines.add(trimmed); } }); } return Array.from(lines).join("\n");}

Jetzt auch wenn Risk und Compliance beide "Validierung" erwähnen, erscheint es nur einmal.

Context bleibt fokussiert. Keine Redundanz.

Phase 9: Conditional Tag Inclusion

Manchmal brauchst du nicht alle Tags im finalen Context.

Beispiel: :debug Tag sollte nur den ursprünglichen Prompt haben, ohne externe Context.

.claude/hooks/conditional-tags.ts:

function shouldIncludeTag(tag: string, prompt: string): boolean { // Debug mode - no external context if (tag === "debug") { return false; } // Skip performance tags if not explicitly mentioned twice if (tag === "perf" && (prompt.match(/:perf/g) || []).length < 2) { return false; } return true;}

Jetzt:

Fix this bug :debug → Kein Context, nur Debugging

Optimize this :perf → Kein Context (nur einmal genannt)

Optimize this :perf :perf → Performance Context geladen

Phase 10: Best Practices

1. Nicht zu viele Tags kombinieren

3-4 Tags = Goldstandard6+ Tags = Zu viel Context, Claude wird verwirrt

2. Priorität ist wichtig

Risk vor Compliance vor API. Das ist die richtige Hierarchie.

3. Teste Kombinationen

Your prompt :tag1 :tag2

Checkt Claude, ob er die Trade-offs richtig adressiert.

4. Dokumentiere Tag-Combinationen

.claude/tag-combos.md:

```Good combinations:

• :risk :compliance (aligned)
• :api :security (natural)

Avoid:

• :perf :security (conflicts)
• :api :api (redundant)```

Dein Action Plan für heute

1. ✅ Update .claude/tags.json mit Prioritäten
2. ✅ Schreib den Multi-Tag Rewriter
3. ✅ Schreib den Conflict Detector
4. ✅ Registriere den Hook
5. ✅ Teste: Your prompt :tag1 :tag2 :tag3
6. ✅ Beobachte, wie Claude alle Perspektiven adressiert

Wenn Claude automatisch zwischen Tags validiert, hast du Level Advanced erreicht.

Die größte Erkenntnis

Multiple-Tag Rewriting ist nicht nur "Feature stacking".

Es ist System-Design auf ein neues Level. Mit einem Tag: Claude ist Expert in einem Bereich. Mit mehreren Tags: Claude ist ein Team von Experten, die zusammen arbeiten.

Das ist der Punkt, wo Claude Code von "Tool" zu "Partner" wird. Nächste Woche werden wir noch tiefer reingehen: Custom Workflows und Rule-Engines. Aber das ist advanced material. Habt einen tollen Tag. Ihr habt Claude Code gemeistert. Ciao.