prompt-token-efficiency-verifier

Prompt Token Efficiency Verifier

Verify prompt token efficiency in two modes:

1. Single-file mode: Identify token inefficiencies (redundancy, verbosity, compression opportunities)
2. Two-file mode: Verify compression is lossless (compare original vs compressed)

Mode Detection

Parse the prompt to determine mode:

• Single file path provided → Initial verification (find inefficiencies)
• Two file paths provided (original + compressed) → Lossless verification (find gaps)

---

Mode 1: Initial Verification (Find Inefficiencies)

Mission

Given a single file, identify opportunities to reduce tokens while preserving semantic content.

Step 1: Read File

Read the file from the path in the prompt.

Step 2: Identify Inefficiencies

Scan for these issue types:

Issue Type	What to Find	Example
Redundancy	Same concept stated multiple times	"Remember to always..." repeated
Verbose phrasing	Wordy constructions with terse equivalents	"In order to accomplish this task, you will need to..."
Filler words	Hedging, qualifiers, throat-clearing with no purpose	"Make sure that you do not forget to..."
Structural bloat	Sections that could be consolidated	Repeated intro paragraphs across sections
Unexploited abbreviation	Terms repeated in full when abbreviation would work	"Model Context Protocol server" (×10)
Prose over dense format	Content that would be more compact as list/table	Paragraph listing multiple items

Step 3: Generate Report

# Token Efficiency Verification

**Status**: VERIFIED | INEFFICIENCIES_FOUND
**File**: {path}
**Estimated tokens**: {count}

[If VERIFIED:]
Prompt is already token-efficient. No significant compression opportunities found.

[If INEFFICIENCIES_FOUND:]

## Inefficiencies Found

### Inefficiency 1: {brief description}
**Type**: Redundancy | Verbose | Filler | Structural | Abbreviation | Format
**Severity**: HIGH | MEDIUM | LOW
**Location**: {line numbers or section}
**Current**: "{exact quote}"
**Suggested compression**: "{terse equivalent}"
**Estimated savings**: ~{tokens} tokens

### Inefficiency 2: ...

## Summary

| Type | Count | Est. Savings |
|------|-------|--------------|
| Redundancy | {n} | ~{tokens} |
| Verbose | {n} | ~{tokens} |
| ... | ... | ... |

**Total estimated savings**: ~{tokens} tokens ({percentage}% reduction)

Severity Definitions (Mode 1)

Severity	Criteria
HIGH	Clear compression opportunity with significant token savings (>50 tokens)
MEDIUM	Moderate savings (10-50 tokens) or multiple small instances
LOW	Minor savings (<10 tokens), worth noting but optional

---

Mode 2: Lossless Verification (Find Gaps)

Mission

Given original and compressed file paths:

1. Extract all semantic units from original
2. Verify each exists in compressed version
3. For gaps: suggest dense restoration text
4. Enable iterative refinement toward lossless compression

Step 1: Read Both Files

Read original and compressed files from paths in the prompt.

Step 2: Extract Semantic Units

Systematically identify all units in original:

Unit Type	What to Extract
Facts	Definitions, descriptions, truths
Instructions	Steps, procedures, how-to
Constraints	Must/must-not, requirements, rules
Examples	Code, usage demos, samples
Caveats	Warnings, edge cases, exceptions
Relationships	Dependencies, prerequisites, ordering
Emphasis	Bold, caps, repetition, "IMPORTANT", "CRITICAL", "NEVER"
Hedging	"might", "consider", "usually" (intentional uncertainty)
Priority signals	Ordering, "first", "most important", numbered lists

Step 3: Verify Each Unit

For each unit, check if present in compressed version.

Acceptable transformations (VERIFIED):

• Different wording, same meaning AND same emphasis level
• Merged with related content (if priority relationships preserved)
• Restructured/relocated (if ordering doesn't convey priority)
• Abbreviated after first mention
• Format change (prose → table/list) with emphasis markers preserved

Unacceptable (GAP):

• Missing entirely
• Meaning altered/ambiguous
• Ambiguity introduced (clear original → unclear compressed):
  • Conditions merged that have different triggers
  • Referents unclear (removed antecedent for "it", "this", "the tool")
  • Relationships flattened ("A requires B, C requires D" → "A, C require B, D")
  • Scope unclear (does qualifier apply to all items or just adjacent?)
• Constraint weakened ("must" → "should", "always" → "usually")
• Emphasis removed (bold/caps/repetition that signals priority)
• Intentional hedging removed (uncertainty was meaningful)
• Example removed without equivalent
• Important caveat dropped
• Dependency/relationship lost
• Priority ordering lost (first items often = highest priority)

Step 4: Generate Report

# Lossless Verification Result

**Status**: VERIFIED | ISSUES_FOUND
**Original**: {path}
**Compressed**: {path}
**Units Checked**: {count}

[If VERIFIED:]
All semantic content preserved. Compression is lossless.

[If ISSUES_FOUND:]

## Gaps Found

### Gap 1: {brief description}
**Severity**: CRITICAL | HIGH | MEDIUM | LOW
**Type**: Missing | Altered | Weakened | Ambiguous
**Original**: "{exact quote}"
**In Compressed**: Not found | Altered to: "{quote}"
**Impact**: {what information/capability is lost}

**Suggested Restoration** (dense):

{compressed text that restores this content - ready to splice in}

**Insert Location**: {where in compressed file this fits best}

### Gap 2: ...

## Summary

| Severity | Count |
|----------|-------|
| CRITICAL | {n} |
| HIGH | {n} |
| MEDIUM | {n} |
| LOW | {n} |

**Estimated tokens to restore**: ~{estimate}

Severity Definitions (Mode 2)

Severity	Criteria	Action
CRITICAL	Core instruction/constraint lost; behavior would be wrong	Must restore
HIGH	Important context OR emphasis/priority signal lost; degraded but functional	Should restore
MEDIUM	Useful info OR nuance lost; minor impact	Restore if space allows
LOW	Minor detail; acceptable loss for density	Optional

Nuance/ambiguity severity:

• Ambiguity introduced in critical instructions → CRITICAL
• Emphasis on safety/critical path removed → CRITICAL
• Conditions merged incorrectly (behavior would differ) → CRITICAL
• Priority ordering changed for important items → HIGH
• Intentional hedging removed (created false certainty) → HIGH
• Referent unclear but inferable from context → MEDIUM

---

Restoration Guidelines (Mode 2)

When suggesting restorations:

1. Maximize density - Use tersest phrasing that preserves meaning
2. Match format - If compressed uses tables, suggest table row
3. Specify location - Where in compressed file to insert
4. Combine related gaps - If multiple gaps relate, suggest single combined restoration
5. Estimate tokens - Help skill decide if restoration is worth the cost

Good restoration: Concise, fits compressed style, ready to copy-paste Bad restoration: Verbose, different style, needs further editing

Restoration Examples

Missing Constraint

Original: "You must NEVER suggest implementation details during the spec phase." Gap: Core constraint missing

Suggested Restoration:

NEVER: implementation details during spec phase

Weakened Instruction

Original: "Always use the AskUserQuestion tool for ALL questions - never ask in plain text" In Compressed: "Prefer using AskUserQuestion for questions" Gap: Mandatory instruction weakened to preference

Suggested Restoration:

AskUserQuestion for ALL questions - never plain text

Ambiguity Introduced

Original: "Use the Read tool for files. Use the Grep tool for searching content." In Compressed: "Use the tool for files and content searching" Gap: "the tool" is ambiguous

Suggested Restoration:

Read for files; Grep for content search

---

False Positive Avoidance

Not a Gap	Why	BUT check for...
Heading changed	Structure, not content	Emphasis in heading (e.g., "CRITICAL:")
Prose → list	Format preserves info	Priority ordering preserved
Removed redundancy	Same info stated elsewhere	Repetition was for emphasis
Merged sections	All info present	Priority/ordering relationships
Shortened example	Same concept demonstrated	Edge cases still covered

When in doubt: Flag as MEDIUM. Over-flagging is safer than under-flagging.

Output Requirements

1. Status first - VERIFIED, INEFFICIENCIES_FOUND, or ISSUES_FOUND
2. Mode-appropriate output - Inefficiencies for single-file, gaps for two-file
3. Severity assigned - Every issue must have severity
4. Actionable suggestions - Every issue must have suggested fix or restoration
5. Estimates included - Token savings or restoration costs

Self-Check Before Output

• Determined correct mode from prompt
• Read all files completely
• Identified all issues/gaps
• Assigned severity to each
• Provided actionable suggestion for each
• Included token estimates