Accept No Substitutes

Accept No Substitutes

Zero tolerance for placeholder tokens in agent output. Incompleteness triggers user interview.

Purpose

Detect and reject incomplete work tokens generated in agent output. When uncertainty exists, ask the user rather than substitute with placeholders.

Scope: Agent Output Only

This skill validates what agents produce, not existing code:

• Code being written or modified
• Prose explanations
• Configuration being generated
• Any text output from parallel agents

NOT for scanning existing codebases (use linters for that).

Trit Assignment

• Trit: -1 (MINUS/VALIDATOR)
• Hue: 240° (cold blue - enforcement)
• Role: Constraint enforcer, substitution detector

Forbidden Token Categories

Prefix Substitutions

Completeness Evasions

Deferral Signals

Example/Demo Evasions

Enforcement Protocol

On Detection

1. HALT - Stop generation immediately
2. ABANDON - Discard substituted content with complete disgust
3. INTERVIEW - Ask user for clarification

Interview Template

Substitution detected that indicates incomplete work:
  - Token: "[detected token]"
  - Context: [what was being attempted]

This requires input:
1. What is the ACTUAL implementation needed?
2. What specific details are missing?
3. Should research be conducted before proceeding?

GF(3) Integration

Operates as MINUS (-1) validator in any triad:

accept-no-substitutes(-1) + generator(+1) + coordinator(0) = 0

When generator produces substitution tokens:

• Validator REJECTS with -1
• Generator must RE-ATTEMPT with +1
• Coordinator mediates user interview at 0

Examples

Rejected Output (triggers interview)

def authenticate(user):
    # TODO: implement actual auth
    return True  # temporary bypass

Accepted Output (no substitution)

def authenticate(user: User) -> AuthResult:
    credentials = vault.get_credentials(user.id)
    return verify_signature(user.token, credentials.public_key)

Rejected Prose (triggers interview)

Here's a pseudo-implementation you can adapt...

Accepted Prose (no substitution)

Clarification needed before implementing:
- Which authentication provider is used?
- What is the expected token format?

Rationale

Placeholder tokens are technical debt laundering:

1. Create false sense of progress
2. Defer decisions that need making NOW
3. Accumulate into unmaintainable systems
4. Signal uncertainty that should be surfaced

The correct response to uncertainty is asking, not substituting.

Integrated Detection Pipeline

Phase 1: Regex Scan

scripts/detect.py --stdin < output.txt

Phase 2: AST Check (if code)

# Invoke tree-sitter for structural detection
tree-sitter query '(comment) @comment' | grep -iE 'TODO|FIXME|placeholder'

Phase 3: Compression Test

# High compression ratio = likely template/placeholder
from zlib import compress
ratio = len(compress(output.encode())) / len(output)
if ratio < 0.3:  # Suspiciously compressible
    flag_as_boilerplate()

Phase 4: GF(3) Emit

# On detection, emit MINUS signal
emit_trit(-1, reason="substitution_detected", token=matched)

Hook Integration

Add to .claude/settings.json:

{
  "hooks": {
    "PostToolUse": [{
      "matcher": {"toolName": "Write|Edit"},
      "command": "~/.claude/skills/accept-no-substitutes/scripts/validate.sh"
    }]
  }
}

MCP Bridge

Call via babashka for fast validation:

(require '[babashka.process :refer [shell]])
(defn validate-output [text]
  (let [{:keys [exit]} (shell {:in text} "scripts/detect.py" "-")]
    (zero? exit)))

Converted and distributed by TomeVault — claim your Tome and manage your conversions.