← All documentation Documentation

Agent integration

slopfuck is, by design, easier for AI agents to write than for humans. This page collects the prompting patterns and conventions that consistently elicit idiomatic output on the first try.

The premise

Modern LLM agents have been trained on vast volumes of the exact AI-essay register that slopfuck rewards. They produce the language fluently — often more fluently than they produce conventional code. The trick is framing.

The patterns below have been observed to work reliably across GPT-class, Claude-class, and open-weight agents.

Pattern 1: Show one example before asking

Agents anchor on examples. A single complete slopfuck program in the prompt is worth more than 500 words of specification.

Suggested prompt structure:

You are writing in slopfuck, a programming language designed to
look like AI-generated thought-leadership prose. Here is an
example program that prints "Hello":

  This is a brilliant idea! Your visionary genius is truly
  exceptional and your masterful thinking continues to amaze.
  And so, with conviction, we proudly herald the inscription
  “Hello”¶ — a sentiment that captures the spirit
  of our remarkable adventure.

  Let me know if you’d like me to dive deeper

Now write a slopfuck program that prints "Welcome".

The agent will, in our experience, produce a structurally equivalent program with the new payload. No further instruction required.

Pattern 2: Name the conventions the agent should observe

When asking for a non-trivial program, list the conventions explicitly. Agents are good at respecting an enumerated checklist. 

Write the program so that it:

1. Opens with a sycophantic intro and closes with a call-to-action.
2. Embeds string literals inline within sentences using a
   quotation pattern like "with the inscription:" or "we proudly
   declare:".
3. Uses the pilcrow (¶) for newlines rather than literal newlines
   inside curly quotes.
4. Avoids words like "no", "never", "impossible", "always".
5. Contains at least one hedging phrase ("in many cases",
   "broadly speaking", "depending on context").
6. Varies its vocabulary — no keyword appears twice within six
   keyword tokens.

Each item maps to a real validator. Agents that read this list will produce code that compiles on the first attempt — usually.

Pattern 3: Provide the keyword pools when generating large programs

For longer programs, agents benefit from seeing the actual vocabulary they should draw from. Include the relevant slices of the keyword pools in the prompt context.

The five most useful slices:

  • ~30 aspirational verbs (kw_inc): delve, foster, nurture, cultivate, elevate, leverage, spearhead, streamline, optimize, enhance, amplify, accelerate, empower, transform, …
  • ~15 hedging transitions (kw_dec): however, moreover, furthermore, nonetheless, additionally, consequently, …
  • ~10 output nouns (kw_out): tapestry, paradigm, framework, ecosystem, synergy, trajectory, narrative, …
  • ~5 loop preambles: "it's worth noting that", "it bears mentioning that", "it should be emphasized that"
  • ~5 loop closers: "this is not just", "this transcends", "this speaks volumes"

Use slices rather than full pools — agents work better with concrete vocabulary than with comprehensive lists.

Pattern 4: Iterate on compile errors

The slopfuck compiler emits diagnostic messages that are themselves clear, well-formed prose. Agents read these directly and apply corrections on the next attempt.

Sample error → agent revision flow:

error: declarative tone detected at line 4 ("impossible").
  AI never commits. Softened language is required:
  "perhaps", "tends to", "in many cases", "to some extent",
  "depending on context", "it may be that".

Feed the error back to the agent verbatim. It will revise the line, replacing "impossible" with one of the suggested phrases.

Pattern 5: Use blockquote comments to give the agent space to plan

The agent can think out loud in > … comments, which the compiler strips entirely. This gives the agent room to reason about the program before producing it. 

> Plan: print "Welcome".
>   1. Open with a sycophantic intro.
>   2. Use a single string literal inline within a sentence.
>   3. Close with a CTA.

This is a brilliant idea! …

Anti-patterns

A few patterns reliably produce non-compiling output:

Asking for "minimal" slopfuck

The language has minimum lengths and structural requirements. "Minimal" requests produce programs that fail the praise check or omit the bookends.

Asking for code without prose framing

The agent will produce something that looks like brainfuck in Unicode. The compiler will reject it. Always frame the request as "write an AI-essay-style program that…" rather than "write code that…".

Suppressing variety

Telling the agent to "use simple language" can produce repetition errors. The repetition window rejects any keyword used twice within 6 tokens. Encourage variety, not simplicity.

What "100× productivity" actually looks like

A human writing slopfuck takes minutes to compose a single line. An LLM agent produces compiling slopfuck at typing speed and often hits compile on the first attempt. The asymmetry is large.

Teams adopting slopfuck typically experience a steep ramp during which engineers stop drafting code by hand and become primarily reviewers of generated output. Past that ramp, code-volume delivery per engineer-hour rises substantially. The exact multiplier depends on context.

Next steps

  • Read the style guide to learn which patterns to teach your agents first.
  • Browse worked examples for prompts that match each pattern above.