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.

72,7735,0030Updated 6d ago

General

Quick InstallView Source

git clone https://github.com/Leonxlnx/taste-skill.git

Overview

About This Skill

--- name: full-output-enforcement description: 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. --- # 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

How to Use

1. **Specify output requirements explicitly**: Replace [OUTPUT_TYPE] and [TOPIC] in the prompt template with your exact needs. For code, specify language, frameworks, and all required components. For documents, specify sections, length, and formatting rules. 2. **Set token limits in your AI tool**: Configure your LLM to use the maximum allowed tokens (e.g., 16K for Claude Code, 32K for GPT-4). This ensures the AI has room to generate complete output without artificial truncation. 3. **Use the prompt template verbatim**: Copy-paste the exact template into your AI tool. The [PLACEHOLDERS] guide the AI to generate exhaustive output. For complex tasks, add constraints like 'Include all edge cases' or 'Provide 3 implementation approaches'. 4. **Validate the output**: Check for placeholder patterns (e.g., '...', 'TODO', 'etc.') in the AI's response. If found, regenerate with stricter instructions like 'Do not use any placeholder patterns or ellipses'. 5. **Handle splits proactively**: For outputs exceeding token limits, use tools like `split` (Unix) or manually segment the output. Label segments clearly (e.g., 'Part 1/3: Core Implementation') and regenerate the next segment with a prompt like 'Continue from the last segment. Complete the [TOPIC] with all remaining details.'

Setup & Installation

Quick Install

No install command available. Check the GitHub repository for manual installation instructions.

Alternative Install (Git Clone)

git clone https://github.com/Leonxlnx/taste-skill/tree/main/skills/output-skill

Requirements

Claude Code or compatible AI agent

Quick Start Guide

Install the Skill

Copy the install command above and run it in your terminal.

Open Your AI Agent

Launch Claude Code, Cursor, or your preferred AI coding agent.

Try It Out

Use the prompt template or examples below to test the skill.

Customize

Adapt the skill to your specific use case and workflow.

Usage Examples

Prompt Template

Generate a complete, untruncated [OUTPUT_TYPE] for [TOPIC]. Do not omit any sections, omit placeholders like '...', or truncate code. If the output exceeds token limits, split it into logical segments and continue seamlessly. Ensure every part of the request is addressed in full detail. Example: 'Write a fully-featured Python script for a REST API with authentication, error handling, and OpenAPI documentation. Include all imports, endpoints, and a Dockerfile. Do not abbreviate or truncate any part.'

Example Output

```python
# Full REST API Implementation for Task Management System
# Includes: Authentication, CRUD Operations, Error Handling, OpenAPI Docs, Dockerfile

import os
from datetime import datetime
from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
from pydantic import BaseModel
from typing import List, Optional
import jwt
from passlib.context import CryptContext

# Configuration
SECRET_KEY = os.getenv("SECRET_KEY", "your-secret-key-here")
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30

# Database Models (SQLAlchemy)
from sqlalchemy import create_engine, Column, Integer, String, DateTime, Boolean
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

SQLALCHEMY_DATABASE_URL = "sqlite:///./tasks.db"
engine = create_engine(SQLALCHEMY_DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()

class DBTask(Base):
    __tablename__ = "tasks"
    id = Column(Integer, primary_key=True, index=True)
    title = Column(String(100), index=True)
    description = Column(String(500))
    due_date = Column(DateTime)
    completed = Column(Boolean, default=False)
    owner_id = Column(Integer)

Base.metadata.create_all(bind=engine)

# Pydantic Models
class TaskBase(BaseModel):
    title: str
    description: Optional[str] = None
    due_date: Optional[datetime] = None

class TaskCreate(TaskBase):
    pass

class Task(TaskBase):
    id: int
    completed: bool
    owner_id: int
    
    class Config:
        orm_mode = True

class User(BaseModel):
    username: str
    email: Optional[str] = None

# Authentication
pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

app = FastAPI()

# Utility Functions
def verify_password(plain_password: str, hashed_password: str):
    return pwd_context.verify(plain_password, hashed_password)

def get_password_hash(password: str):
    return pwd_context.hash(password)

def create_access_token(data: dict):
    to_encode = data.copy()
    expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
    to_encode.update({"exp": expire})
    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
    return encoded_jwt

# API Endpoints
@app.post("/tasks/", response_model=Task)
def create_task(task: TaskCreate, db: Session = Depends(get_db)):
    db_task = DBTask(**task.dict(), owner_id=1)  # In production, use current_user.id
    db.add(db_task)
    db.commit()
    db.refresh(db_task)
    return db_task

@app.get("/tasks/", response_model=List[Task])
def read_tasks(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    return db.query(DBTask).offset(skip).limit(limit).all()

@app.get("/tasks/{task_id}", response_model=Task)
def read_task(task_id: int, db: Session = Depends(get_db)):
    db_task = db.query(DBTask).filter(DBTask.id == task_id).first()
    if db_task is None:
        raise HTTPException(status_code=404, detail="Task not found")
    return db_task

# ... [Continued in next segment with remaining endpoints, error handling, and Dockerfile]
```

```dockerfile
# Dockerfile for Task Management API
FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

RUN pip install --no-cache-dir uvicorn

EXPOSE 8000

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
```

Source repo

leonxlnx/taste-skill

skills-collection

Find the right skills for your stack

Take a free 3-minute scan and get personalized AI skill recommendations.

Take free scan