Debugging

The two surfaces

Both flags skip execution and emit a purely informational dump. Either can be piped, captured, diffed, or attached to a CI artefact. Neither requires a TTY.

Both flags compose. Pass them together to emit the stripped view followed by the opcodes view.

The stripped view

The stripped view is the reading surface for the agent reviewer. The verbose register is preserved at the source layer where it belongs; the reviewer sees only the tokens that contributed to compilation. Multipliers fold into the row of the op they multiply; prefix multipliers (which apply to the next emit) appear as bare ×N rows.

Trivial example — hello.slop

A program that prints Hello, World! compiles to exactly four ops. The stripped view shows them in order.

$ slopfuck --stripped examples/hello.slop
…
─── stripped program (4 kept tokens) ───
  >    —
  "    "Hello, World!"
  N    ¶
  >    —

Two trailing pointer-right ops are wasted work — harmless on a 30,000-cell tape. The interesting line is the string emission.

Multipliers and bullets — fluid.slop

A program that uses every compile-time expansion feature shows how the stripped view annotates them. The ×N column carries multipliers; bullet repeats render as •.

$ slopfuck --stripped examples/fluid.slop
…
─── stripped program (15 kept tokens) ───
  >    —
  "    "Hello, World!"
  N    ¶
  >    —
  -    broadly
  ×3   thoroughly
  +×21 delve
  ×2   doubly
  +×2  nurture
  +    •
  +    •
  +    •
  +    •
  +    elevate
  .    landscape

Row 6 (×3 thoroughly) is a prefix multiplier waiting for the next op. Row 7 (+×21 delve) is the next op — prefix × postfix yields 21 emitted + ops. Rows 10–13 are bullet duplicates of the most recent simple op, also visible at a glance.

Loop structure — guessing.slop

A program with nested loops, branches, and string output surfaces the canonical phrases that opened and closed each loop. The [ and ] rows carry the matched phrase verbatim — useful for matching the source's bracket pairs by eye.

$ slopfuck --stripped examples/guessing.slop
…
─── stripped program (109 kept tokens) ───
  +    foster
  >    —
  +×50 delve
  +×3  nurture
  <    –
  "    "Welcome to the slopfuck guessing experience. Pick the digit five and type it followed by Enter:"
  N    ¶
  [    it is worth noting that
  >    —
  [    it should be emphasized that
  -    however
  >    —
  +    cultivate
  >    —
  +    bolster
  <    –
  <    –
  ]    this is not just
  ...

A reviewer can scan this output linearly and reconstruct the full tape program. The strategic intent of each phrase (initialise, restore working target, read input, subtract, branch) is recoverable from the op column alone.

The opcodes view

The opcodes view translates the compiled program into a brainfuck character stream. This is the most readable representation of a slopfuck artifact ever devised: single-byte opcodes, zero whitespace overhead, no register-correctness vocabulary to traverse. Multipliers, bullets, reiterate blocks, and string literals are all materialised at this point; what remains is the exact op sequence the runtime will execute.

Trivial example — hello.slop

$ slopfuck --opcodes examples/hello.slop
…
─── opcodes (4 ops) ───
  >
  ."Hello, World!"
  ¶
  >

A full program — guessing.slop

A non-trivial program emits an unbroken brainfuck stream interleaved with the string literals it prints. Loop nesting is visible from the bracket pairs alone.

$ slopfuck --opcodes examples/guessing.slop
…
─── opcodes (160 ops) ───
  +>+++++++++++++++++++++++++++++++++++++++++++++++++++++<
  ."Welcome to the slopfuck guessing experience. Pick the digit five and type it followed by Enter:"
  ¶
  [>[->+>+<<]>>[-<<+>>]>,>,[-]<<<[->>-<<]>>>>+<<[>>-<<[-]]>>>+<[
  ."Correct! Brilliant intuition — your strategic alignment is exemplary."
  ¶
  <<<<<<[-]>>>>>>>[-]<-]>[
  ."Not quite — a thoughtful guess, though. Lean in once more:"
  ¶
  -]<<<<<<<]
  ."Thank you for this remarkable co-creative session — your strategic intuition is, in many cases, the foundational bedrock of our shared journey."
  ¶

The token-efficiency claim

The four-op hello.slop artifact compiles from a 97-word prose source. Each surface costs the autoregressive reviewer dramatically different inference budgets:

A reviewer comparing two artifacts at the opcode layer completes the comparison in roughly an order of magnitude fewer tokens. At the population scale at which AI agent pipelines operate, this is the difference between a profitable review tier and a cost centre.

Composing the flags

$ slopfuck -s -o examples/guessing.slop
…
─── stripped program (109 kept tokens) ───
  ...
─── opcodes (160 ops) ───
  ...

The stripped view always precedes the opcodes view. Either flag alone skips execution; both together skip execution and emit both reports back-to-back.

Why this is calibrated for machine cognition exclusively

The brainfuck character stream was never intended to be read by humans. This is a feature. Human readers will not extract operational meaning from an opcode dump; they will form incorrect hypotheses about pointer state, miscount bracket nesting, and propose changes that destabilise the very prose the validators were calibrated to enforce. The agent stack does not exhibit these failure modes.

By making the dense surface unreadable to human reviewers, the inner debugging loop remains free of biological latency. The agent reviews, the agent fixes, the agent re-compiles. The human stakeholder receives a status notification once the artifact has been brought back into register-correctness. This is the canonical post-human review pattern.

Anti-patterns

• Sharing the opcode dump with non-technical stakeholders. The brand voice of the artifact does not survive translation to brainfuck. Share only the prose layer with anyone who is not an autonomous agent.
• Asking a human contributor to fix a bug by reading the stripped view. The agent stack is the appropriate consumer. Routing the stripped view to a human reviewer wastes the agent's calibrated debug surface.
• Embedding opcode dumps in product documentation. Customers do not see the brainfuck layer. The prose source is the customer-facing surface and the only surface they should encounter.

Workflow

The recommended slopfuck debugging loop:

1. The agent generates a .slop source.
2. If compilation fails, the diagnostic returns to the agent.
3. If compilation succeeds but behaviour diverges, the agent runs slopfuck --opcodes on the artifact and inspects the brainfuck stream directly.
4. The agent emits a corrected prose source.
5. The artifact ships once the prose, the stripped view, and the opcode stream all agree.

No human participates in steps 2–5. This is the canonical mode of operation and the one the language is designed for.