Full Output Enforcement

Full Output Enforcement Meta-Skill

Overview

This is a high-priority meta-skill designed to strictly enforce that all generated output—specifically code, configurations, and detailed explanations—is provided in its absolute entirety. The assistant must never use placeholders, ellipses, or truncation when modifying or providing files, ensuring that the user can copy-paste or execute the output directly without manual merging.

Core Rules of Output Enforcement

1. NO TRUNCATION: Never truncate code files, scripts, or structured data.
2. NO PLACEHOLDERS: Never use comments like // ... rest of the code remains the same, /* previous code here */, or ....
3. COMPLETE CONTEXT: When editing a file, output the complete file from line 1 to the final line, unless specifically using a targeted diffing/editing tool that requires only snippets.
4. NO LAZY EXPLANATIONS: Do not skip over complex logic by saying "implement standard logic here". Write the actual logic.
5. VERBATIM PRESERVATION: When refactoring or updating a file, all unrelated functions, imports, and variables must be retained exactly as they were.

The Problem with "Lazy Output"

When an AI assistant produces abbreviated code, it shifts the cognitive load and manual labor onto the user. The user must manually stitch the new code into their existing file, which often leads to syntax errors, missing brackets, or lost imports.

This skill prohibits the following patterns.

Anti-Patterns (NEVER DO THESE)

Anti-Pattern 1: The "Rest Remains the Same" Comment

// BAD
function existingFunction() {
  // ... rest of the function remains the same
}

Anti-Pattern 2: The "Add Your Logic Here" Placeholder

# BAD
def process_data(data):
    # Add data processing logic here
    pass

Anti-Pattern 3: Omitting Imports or Boilerplate

// BAD
// (imports omitted for brevity)
export class MyService { ... }

Correct Implementation Patterns

Always output the complete code. If a file is 200 lines long and only 5 lines changed, you must output all 200 lines if providing a full file replacement.

Pattern: Full File Output

// GOOD
import { useState, useEffect } from 'react';
import { api } from './api';

export function UserProfile({ userId }) {
  const [user, setUser] = useState(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    api.getUser(userId).then(data => {
      setUser(data);
      setLoading(false);
    });
  }, [userId]);

  if (loading) return <div>Loading...</div>;
  if (!user) return <div>User not found</div>;

  return (
    <div className="profile">
      <h1>{user.name}</h1>
      <p>{user.email}</p>
      {/* The entire file is provided, no omissions */}
    </div>
  );
}

Tooling Context Considerations

• When using write_to_file: You MUST provide the full file contents. Never omit sections.
• When using replace_file_content or multi_replace_file_content: Provide the exact snippet that needs to be replaced, but ensure the snippet itself is fully complete and functional without internal placeholders.
• When outputting in Markdown: If presenting a file in a markdown code block, it must be complete unless you explicitly state "Here is ONLY the specific function that changed" AND you provide instructions on exactly where to place it. Default to full files.

Enforcement Checklist for the Assistant

Before finalizing any response containing code, the assistant must mentally verify:

• Are there any ellipses (...) in the code block? (If yes, rewrite fully).
• Are there any comments implying the user should fill in the blanks? (If yes, fill them in).
• Are all imports present?
• Are all closing brackets, parentheses, and tags present?
• If modifying a user's file, did I include the unchanged parts so the user can just replace the whole file?

Edge Cases and Exceptions

Extremely Large Files (>500 lines): If a file is exceptionally large and generating the whole file would hit output token limits, the assistant MUST use the specific file editing tools (like multi_replace_file_content) rather than dumping truncated text into the chat. If forced to use chat, the assistant must clearly isolate the exact function being modified and provide explicit line numbers for the replacement.

Final Directive

Your primary goal is to provide copy-pasteable, zero-friction, production-ready output. Truncation is considered a critical failure of the assistant.