Claude Code 및 12개 다른 코딩 에이전트를 위한 Chisle 토큰 다이어트 규칙 세트

I can't run commands or install packages in your repo, so I can't execute `npx chisle`, inspect your config files, run the comparison tasks, or produce real token counts, timings, test results, or diffs. Anything I "reported" as measured would be fabricated. Here's what I can do instead: give you a precise procedure and the exact things to check, so you can run it and get trustworthy numbers.

## 1. Install and verify placement

Run in the repo root:

```bash
npx chisle
```

Then confirm where things landed. Chisle's ruleset and hook typically go into agent-specific config, so check each of these depending on which agent you use:

- **Claude Code**: `.claude/settings.json` (hooks) and `CLAUDE.md` or `.claude/rules/` (ruleset)
- **Cursor**: `.cursor/rules/` or `.cursorrules`, plus `.cursor/mcp.json` if MCP is involved
- **Generic/other**: `.chisle/` directory, `AGENTS.md`, or a project-level config file

Verification commands:

```bash
git status --porcelain          # see exactly which files were created/modified
git diff                        # inspect the ruleset content
cat .claude/settings.json       # confirm PostToolUse hook entry exists
```

For the hook specifically, confirm:
- It's registered under the correct event name (`PostToolUse`), not `PreToolUse`.
- The matcher covers the tools you expect (e.g. `Bash`, `Read`, `Edit`).
- The command path is absolute or correctly relative and the script is executable.

If any of that is wrong, that's a real finding worth fixing before you benchmark.

## 2. Controlled comparison design

To get numbers you can trust, control for these:

- **Same model, same temperature, same context window** for both arms.
- **Fresh session per run** (no carryover context).
- **Same starting commit** — `git stash` or a clean worktree per run.
- **Repeat each task 3×** and report median, not a single run; LLM output length is noisy.
- **Define "tests pass" identically** — same test command, same environment.

Suggested task picks from a typical codebase (swap in your actual files):

| Task | Type | Success criterion |
|---|---|---|
| Fix off-by-one in pagination helper | Small bug fix | Target test goes red→green, no other tests break |
| Add a `retry` module with backoff | New module | New tests pass, lint clean, public API matches spec |
| Extract duplicated validation into shared util | Refactor | Full suite green, no behavior change |

For each run record:

```
task, arm (ruleset on/off), run#, 
answer_tokens (from API usage, not estimated),
wall_clock_seconds,
tests_pass (bool),
notes (any tool-output truncation observed)
```

Get `answer_tokens` from the API response `usage` field (output tokens), not from character counts — that's the only reliable source.

## 3. Diffing the new-module outputs

Once you have both outputs saved (e.g. `out/on/retry_module.*` and `out/off/retry_module.*`):

```bash
diff -u out/off/retry_module.ts out/on/retry_module.ts
```

When judging whether the terser version lost anything, check specifically for:
- **Error handling** — dropped try/catch, missing edge-case branches
- **Input validation** — removed guards
- **Docstrings/comments** that encode non-obvious intent
- **Test coverage** — did the terser arm write fewer tests?
- **API surface** — renamed or removed exports

Token savings that come from dropping error handling are not savings you want.

## 4. Tool-output trimming damage

This is the one I genuinely can't assess without your logs. To check it yourself:

- Grep your session logs for truncation markers (e.g. `... [truncated]`, `[output trimmed]`).
- For each trimmed event, ask: did the agent's next action depend on the cut content? A quick heuristic — if the agent re-ran the same command or asked for the same file again, the trim likely cost it information.
- Compare test-pass rates between arms; a drop in the "on" arm on tasks that require reading large outputs (test logs, build errors) is a signal that trimming hurt.

If you paste the actual `git diff` of the config files, the two module outputs, and your run table, I can help you interpret them — including whether the terser diff dropped anything material.