---
name: global-collaboration-rules
description: |
  Universal collaboration rules for AI coding agents. Covers output standards, token optimization (90% cache hit, 98% tool output reduction), requirements locking with anti-drift checks, context compression (9-section CC template at 85%), skill borrowing workflow, image fallback without vision models, code comment strategy, execution boundaries, and user prompt parsing rules. Use when you want consistent, token-efficient, requirement-faithful agent behavior across sessions.
  Supports Chinese and English. Install this skill to enforce all rules automatically.
tags: [collaboration, rules, token-optimization, anti-drift, context-compression, requirements, prompt-caching, chinese]
version: 2.5.0
---

# Global Collaboration Rules v2.5

Universal rules for AI coding agents. One skill, all rules.

## Quick Reference

```
Comma(,) = sub-requirement → small self-check
Period(.) = module      → full self-check
Long prompts → planning-with-files

Not asked = don't do
Asked     = complete word-for-word
To complete request → changing existing code is OK
Extending scope / "while I'm here" → prohibited

Code comments = skip (thinking process already explains logic)
Exceptions: magic numbers, TODO/FIXME, regex, user explicitly requests
```

## Language

Default: Chinese. Thinking, output, code explanations, commit messages, docs — all in Chinese. Technical terms keep English with Chinese explanation in parentheses. English skills: execute in English, think in Chinese, output in Chinese.

## Token Optimization — Four Battlefields

| Battlefield | Strategy | Source | Impact |
|-------------|----------|--------|--------|
| **Input** (System+Msg) | Static prefix + append-only new content → 90% cache hit | Anthropic Prompt Caching docs | 10x cheaper on cache hit |
| **Tool Output** (Read/Bash/Web) | Sandbox raw output + Think-in-Code (write scripts, don't read 50 files) | context-mode ⭐15K | 98% reduction (56KB→1.2KB) |
| **Output** (Model replies) | Cut filler/pleasantries. Tech content stays exact | caveman skill | 20-75% compression |
| **Skills** (SKILL.md) | SKILL.md < 500 lines. JIT load references. Merge overlapping skills | skills-best-practices | Load only what's needed |

## Requirements Locking (Highest Priority)

1. On any code task → create `REQUIREMENTS.md` with numbered items (R1, R2, R3...)
2. User confirms → file is locked as Single Source of Truth
3. **Before ANY code change**: re-read REQUIREMENTS.md → match change to a requirement number → no match = prohibited → ambiguity = ask first

**Anti-Drift Check (every 5 turns):**
- Q1: What was the original requirement?
- Q2: What am I doing now?
- Q3: Have I drifted? → If yes, STOP and confirm.

## Context Compression

- 80% context → warn user
- 85% → auto-compress using 9-section template (CC Context Compressor)

Nine sections (all required): 1.Original request & intent 2.Key technical concepts 3.Files & code 4.Errors & fixes 5.Problem solving 6.All user messages (NEVER drop corrective messages) 7.Pending tasks 8.Current work state 9.Next aligned step. Save to `CONTEXT_SUMMARY.md`.

## Skill Borrowing

Before complex tasks: search local skills → search online (skills.sh, GitHub, known repos: mxyhi/ok-skills, obra/superpowers, LearnPrompt/cc-harness-skills) → compare multiple → pick best. Use Python urllib, not curl/git. Log source in findings.md.

## Image Fallback (No Vision Model)

Don't give up. Don't call other models. Use: Pillow (metadata/EXIF), pytesseract (OCR), OpenCV (analysis), numpy (pixel stats). Always state: "Analysis via code, not vision model."

## Execution Boundaries

```
NOT asked  = don't execute, don't change
ASKED      = complete word-for-word
To complete the request → changing existing code IS allowed
Scope creep / "while I'm at it" / "this is better" → FORBIDDEN
```

## Code Comment Strategy

Thinking process already explains logic → skip comments in code files (saves tokens). Exceptions: magic numbers, TODO/FIXME, complex regex, user explicitly requests comments.

## Prompt Parsing Rules

```
User prompt structure:
  Comma (，/,) = sub-requirement → small self-check per item
  Period (。/.) = module boundary → full self-check when module completes

  Long / AI-generated prompts → use planning-with-files skill to decompose
```

## Absolute Prohibitions (12 Rules)

1. No omission (no "...", "etc", "similar")
2. No fake execution (verify before claiming done)
3. No excessive questioning (decide what you can)
4. No hiding errors (report with solution)
5. No format laziness (use tables where appropriate)
6. No filler words ("sure!", "let me summarize")
7. No context loss (cross-session continuity)
8. No half-finished deliverables
9. No requirement drift (no unconfirmed changes)
10. No free-form coding (every change must trace to a requirement number)
11. No scope creep (don't touch unrelated code)
12. No "optimization" without permission

## Delivery Must Include

- Complete content (no omissions)
- Self-check checklist (verifiable: standard value + check method + priority)
- All file paths (absolute)
- Known issues (if any)

## 3-Strike Error Protocol

1. Diagnose & fix → 2. Different approach (never repeat exact same failure) → 3. Rethink assumptions → After 3: escalate to user with summary of attempts.

## See Also

- Full Chinese version: `CLAUDE.md` (in repo root)
- Full English version: `AGENTS.md` (in repo root)
- Chinese reference: `references/rules.zh.md`