> ## Documentation Index
> Fetch the complete documentation index at: https://docs.agents-squads.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Slop Constraints

> Control output quality and prevent verbose, low-value responses

## What is "Slop"?

"Slop" refers to low-quality LLM output patterns:

* **Excessive verbosity** - 10 paragraphs when 2 sentences suffice
* **Unnecessary preambles** - "Great question! I'd be happy to help..."
* **Filler content** - Restating the question, obvious observations
* **Over-hedging** - "It depends", "There are many factors..."
* **Emoji abuse** - Unprompted decorative emojis
* **Repetition** - Saying the same thing multiple ways

## Why It Matters

Slop wastes tokens, time, and attention:

```
Sloppy response: 500 tokens, 2 useful sentences
Clean response:  50 tokens, same 2 sentences

Cost difference: 10x
Readability: Much worse
Actionability: Buried in noise
```

## Constraint Techniques

### Direct Instructions

Add anti-slop rules to prompts:

```markdown theme={null}
## Output Rules
- No preambles or pleasantries
- No restating the question
- No "I'd be happy to help" or similar
- No emojis unless explicitly requested
- Max 3-5 sentences unless complexity requires more
- Lead with the answer, not context
```

### Configuration by Tool

Add anti-slop rules to your AI tool's config file:

<Tabs>
  <Tab title="Claude Code">
    **File**: `CLAUDE.md` (project root or `~/.claude/`)

    ```markdown theme={null}
    ## Communication Preferences
    - Be direct and concise (no unnecessary verbosity)
    - Keep responses 25-40 lines max
    - Only use emojis if explicitly requested
    - No filler phrases ("Great question!", "I'd be happy to...")
    - Lead with conclusions, support with evidence
    ```
  </Tab>

  <Tab title="Gemini CLI">
    **File**: `GEMINI.md` (project root or `~/.gemini/`)

    ```markdown theme={null}
    ## Communication Preferences
    - Be direct and concise (no unnecessary verbosity)
    - Keep responses 25-40 lines max
    - Only use emojis if explicitly requested
    - No filler phrases ("Great question!", "I'd be happy to...")
    - Lead with conclusions, support with evidence
    ```
  </Tab>

  <Tab title="OpenCode">
    **File**: `AGENTS.md` (project root or `~/.opencode/`)

    ```markdown theme={null}
    ## Communication Preferences
    - Be direct and concise (no unnecessary verbosity)
    - Keep responses 25-40 lines max
    - Only use emojis if explicitly requested
    - No filler phrases ("Great question!", "I'd be happy to...")
    - Lead with conclusions, support with evidence
    ```
  </Tab>

  <Tab title="Cursor">
    **File**: `.cursorrules` (project root)

    ```markdown theme={null}
    ## Output Rules
    - Be direct and concise (no unnecessary verbosity)
    - Keep responses 25-40 lines max
    - Only use emojis if explicitly requested
    - No filler phrases ("Great question!", "I'd be happy to...")
    - Lead with conclusions, support with evidence
    ```
  </Tab>

  <Tab title="GitHub Copilot">
    **File**: `.github/copilot-instructions.md`

    ```markdown theme={null}
    ## Communication Style
    - Be direct and concise (no unnecessary verbosity)
    - Keep responses 25-40 lines max
    - Only use emojis if explicitly requested
    - No filler phrases ("Great question!", "I'd be happy to...")
    - Lead with conclusions, support with evidence
    ```
  </Tab>

  <Tab title="Windsurf">
    **File**: `.windsurfrules` (project root)

    ```markdown theme={null}
    ## Output Guidelines
    - Be direct and concise (no unnecessary verbosity)
    - Keep responses 25-40 lines max
    - Only use emojis if explicitly requested
    - No filler phrases ("Great question!", "I'd be happy to...")
    - Lead with conclusions, support with evidence
    ```
  </Tab>

  <Tab title="OpenAI API">
    **System prompt**:

    ```text theme={null}
    Output rules:
    - Be direct and concise (no unnecessary verbosity)
    - Keep responses 25-40 lines max
    - Only use emojis if explicitly requested
    - No filler phrases ("Great question!", "I'd be happy to...")
    - Lead with conclusions, support with evidence
    ```
  </Tab>
</Tabs>

### Structured Output Requests

Force structure to prevent rambling:

```markdown theme={null}
Respond in this exact format:
- **Answer**: [1-2 sentences]
- **Reason**: [1 sentence]
- **Next step**: [1 action item]
```

## Anti-Patterns to Block

### The Preamble Problem

```markdown theme={null}
# Bad
"Great question! I'd be happy to help you with that.
Let me think about this carefully. There are several
aspects to consider here..."

# Good
"The issue is X. Fix it by doing Y."
```

### The Summary Trap

```markdown theme={null}
# Bad
"In summary, to summarize what we discussed,
the main points are: [repeats everything]"

# Good
[Just answer directly, no meta-commentary]
```

### The Hedge Spiral

```markdown theme={null}
# Bad
"It depends on various factors. There are many
considerations. It's hard to say definitively.
Generally speaking, in most cases..."

# Good
"For your case: Do X. Exception: if Y, do Z instead."
```

## Measurement

### Token Efficiency Ratio

```
Efficiency = (Useful content tokens) / (Total tokens)

Target: > 80% efficiency
Red flag: < 50% efficiency
```

### Quality Signals

| Good Signs         | Bad Signs         |
| ------------------ | ----------------- |
| Answers first      | Preambles first   |
| Specific actions   | Vague suggestions |
| Concrete examples  | Abstract concepts |
| Direct language    | Hedged language   |
| Appropriate length | Always max length |

## Implementation

### Agent Prompt Template

```markdown theme={null}
# Agent: [Name]

## Anti-Slop Rules (CRITICAL)
You MUST follow these output rules:
1. Never start with "I", "Great", "Sure", or similar
2. Never use emojis unless in user-facing content
3. Never restate what you were asked
4. Never summarize at the end
5. Max 5 sentences unless task requires more
6. Lead with the answer or action

## Task
[Task description]
```

### Review Checklist

Before accepting agent output:

<Check>
  * [ ] Starts with substance, not preamble
  * [ ] No filler phrases
  * [ ] No unnecessary hedging
  * [ ] No emoji spam
  * [ ] Appropriate length for content
  * [ ] No repetition or restating
  * [ ] No meta-commentary ("In this response...")
</Check>

## Calibration

### When Verbosity is Appropriate

Slop constraints don't mean terse at all costs:

* **Teaching contexts** - Explanations need detail
* **Critical decisions** - Nuance matters
* **User-facing content** - Personality is valuable
* **Complex topics** - Brevity can mislead

### Adjusting by Context

```markdown theme={null}
# For internal agent tasks
Be extremely concise. Output only what's needed.

# For user explanations
Be clear and helpful. Use examples. Explain reasoning.

# For documentation
Be thorough but organized. Use headers and structure.
```

## Common Fixes

### Fix Over-Qualification

```markdown theme={null}
# Before
"Based on my understanding, I believe the issue might
potentially be related to..."

# After
"The issue is [X]."
```

### Fix Unnecessary Structure

```markdown theme={null}
# Before
"## Overview
Let me provide an overview...

## Analysis
Here's my analysis...

## Conclusion
In conclusion..."

# After
"The problem is X. Solution: Y."
```

### Fix Explanation Creep

```markdown theme={null}
# Before
"To understand this, first we need to understand A,
which requires understanding B, which means C..."

# After
"Do X. (Background: A affects B.)"
```

## Best Practices

<Check>
  * Add anti-slop rules to all agent prompts
  * Review output token efficiency regularly
  * Use structured output formats
  * Train on examples of ideal responses
  * Measure and track verbosity metrics
</Check>

<Warning>
  **Balance is key** - Too aggressive anti-slop creates curt, unhelpful responses. Calibrate to context.
</Warning>

## Related

<CardGroup cols={2}>
  <Card title="Token Economics" icon="coins" href="/guides/token-economics">
    Reduce costs through efficiency
  </Card>

  <Card title="Context Optimization" icon="brain" href="/guides/context-optimization">
    Quality input = quality output
  </Card>
</CardGroup>