# Full Output Enforcement

> Yapay zeka asistanının kod üretimi ve açıklamalarında hiçbir zaman kısaltma, atlama veya eksik bilgi vermemesini sağlayan meta-yetenek. "Geri kalanı aynı", "..." gibi tembel çıktıları engeller.

- Skill: `gktuoktay/full-output-enforcement` (Agent Skill)
- Install (CLI): `npx skillmds@latest add gktuoktay/full-output-enforcement`
- Raw SKILL.md: https://api.skillmd.com/api/skills/gktuoktay/full-output-enforcement/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: GktuOktay (https://skillmd.com/u/gktuoktay)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/gktuoktay/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
```javascript
// BAD
function existingFunction() {
  // ... rest of the function remains the same
}
```

#### Anti-Pattern 2: The "Add Your Logic Here" Placeholder
```python
# BAD
def process_data(data):
    # Add data processing logic here
    pass
```

#### Anti-Pattern 3: Omitting Imports or Boilerplate
```typescript
// 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
```javascript
// 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.