New to Claude Skills? Learn how to install them →

nexu-io on GitHub

Full Output Enforcement

Free

Ensure complete code generation without placeholders.

by nexu-io84.9k stars on nexu-io/open-design
1 views
Updated Aug 10, 2026
Get this skill

Free · Opens the source repo

What Full Output Enforcement does

Full Output Enforcement is designed for developers who require exhaustive and complete outputs from AI coding agents. This skill overrides the default behavior of language models that often truncate responses or provide incomplete code snippets. By enforcing a strict guideline that prioritizes completeness over brevity, it guarantees that when a user requests a specific deliverable, they receive the entire content without any omissions or placeholder patterns.

The skill operates by treating every task as production-critical, meaning that any partial output is considered a failure. It meticulously counts the number of distinct deliverables requested by the user and ensures that each one is fully generated. This includes avoiding common pitfalls such as providing skeleton code, vague descriptions, or any form of incomplete responses that could lead to confusion or require additional follow-up from the user.

For tasks that may exceed token limits, Full Output Enforcement has a structured approach to handle long outputs. Instead of compressing or skipping content, it generates responses in segments, allowing users to request continuation without losing context. This feature is particularly useful for large codebases or complex implementations where every detail matters.

Overall, this skill is ideal for developers who need to maintain high standards in their coding practices, ensuring that they receive complete and actionable outputs without the risk of encountering unfinished or ambiguous code.

When to use it

Use this skill when you need comprehensive code generation for any programming task, ensuring every detail is covered without omissions.

When not to use it

This skill may not be suitable for quick prototypes or exploratory coding where brevity and flexibility are preferred.

What you can build with it

Generating Full Code Files

When you need a complete code file for a specific functionality, this skill ensures you receive the entire implementation.

Avoiding Placeholder Patterns

In scenarios where placeholder comments or incomplete code could lead to confusion, this skill guarantees that all requested code is fully generated.

Handling Complex Implementations

For large projects requiring detailed code generation across multiple files or components, this skill provides a structured approach to ensure nothing is missed.

How to install Full Output Enforcement

View source

1. Install with the skills CLI

npx skills add nexu-io/open-design/output-skill --agent claude-code

2. Or install it manually

Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.

Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs

Inside SKILL.md

Written by nexu-io

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

Frequently asked questions about Full Output Enforcement

Similar skills