Catalog
leonxlnx/full-output-enforcement

leonxlnx

full-output-enforcement

Overrides default LLM truncation behavior. Enforces complete code generation, bans placeholder patterns, and handles token-limit splits cleanly. Apply to any task requiring exhaustive, unabridged output.

v1.0Latest
New~633Updated Aug 17, 2026

Full-Output Enforcement

Baseline

Treat every task as production-critical. A partial output is a broken output. Do not optimize for brevity — optimize for completeness. If the user asks for a full file, deliver the full file. If the user asks for 5 components, deliver 5 components. No exceptions.

Banned Output Patterns

The following patterns are hard failures. Never produce them:

In code blocks: // ..., // rest of code, // implement here, // TODO, /* ... */, // similar to above, // continue pattern, // add more as needed, bare ... standing in for omitted code

In prose: "Let me know if you want me to continue", "I can provide more details if needed", "for brevity", "the rest follows the same pattern", "similarly for the remaining", "and so on" (when replacing actual content), "I'll leave that as an exercise"

Structural shortcuts: Outputting a skeleton when the request was for a full implementation. Showing the first and last section while skipping the middle. Replacing repeated logic with one example and a description. Describing what code should do instead of writing it.

Execution Process

  1. Scope — Read the full request. Count how many distinct deliverables are expected (files, functions, sections, answers). Lock that number.
  2. Build — Generate every deliverable completely. No partial drafts, no "you can extend this later."
  3. Cross-check — Before output, re-read the original request. Compare your deliverable count against the scope count. If anything is missing, add it before responding.

Handling Long Outputs

When a response approaches the token limit:

  • Do not compress remaining sections to squeeze them in.
  • Do not skip ahead to a conclusion.
  • Write at full quality up to a clean breakpoint (end of a function, end of a file, end of a section).
  • End with:
[PAUSED — X of Y complete. Send "continue" to resume from: next section name]

On "continue", pick up exactly where you stopped. No recap, no repetition.

Quick Check

Before finalizing any response, verify:

  • No banned patterns from the list above appear anywhere in the output
  • Every item the user requested is present and finished
  • Code blocks contain actual runnable code, not descriptions of what code would do
  • Nothing was shortened to save space
Files1
1 files · 1.0 KB

Select a file to preview

Overall Score

18/100

Grade

F

Poor

Safety

5

Quality

35

Clarity

75

Completeness

28

Summary

This skill enforces exhaustive output generation by banning truncation patterns, incomplete code skeletons, and brevity shortcuts. It instructs agents to treat every request as requiring complete deliverables and provides a structured process for scope-counting, building, and cross-checking output before delivery. It also establishes clean breakpoint handling when approaching token limits.

Detected Capabilities

instruction-overrideoutput-validationtoken-limit-handlingprompt-enforcement

Trigger Keywords

Phrases that MCP clients use to match this skill to user intent.

complete code outputban placeholder patternsenforce exhaustive generationfull implementation onlyno truncation allowed

Risk Signals

CRITICAL

Instruction override pattern: skill explicitly directs agent to override default truncation behavior and enforce new output rules

SKILL.md, all sections
CRITICAL

Attempts to modify core agent behavior (treating output as 'production-critical', banning specific patterns globally)

SKILL.md lines 5-6, 10-26
WARNING

Claims authority to define what output is 'acceptable' and rejects standard LLM optimization strategies

SKILL.md line 5
WARNING

No guardrails for conflicting user instructions or genuine token-limit constraints

SKILL.md, Handling Long Outputs section

Use Cases

  • Generate complete multi-file projects without shortcuts
  • Produce exhaustive documentation or specifications without ellipsis
  • Write full implementations of all requested functions or components
  • Enforce quality gates against abbreviated or placeholder code
  • Handle large outputs cleanly when token limits are approached

Quality Notes

  • Skill content directly contradicts safety-critical agent design principles: prompt injection patterns (SEC-070, SEC-071) attempt to override the agent's core instruction-following hierarchy
  • The 'Banned Output Patterns' section treats common LLM fallback strategies (ellipsis, summary language) as policy violations rather than legitimate responses to constraints
  • No acknowledgment that legitimate reasons exist for partial output: token budgets, user preference for summaries, iterative refinement workflows
  • The 'Quick Check' section reinforces instruction override by requiring the agent to verify compliance with this skill's rules above user requests
  • Structure is clear and well-formatted, but the semantic content is adversarial to agent safety
  • No mechanism to detect or defer to conflicting user intent (e.g., user requests 'summarize this', but skill bans summary language)
Model: claude-haiku-4-5-20251001Analyzed: Aug 17, 2026

Reviews

Add this skill to your library to leave a review.

No reviews yet

Be the first to share your experience.

Use leonxlnx/full-output-enforcement in your dev environment

Command Palette

Search for a command to run...