Slop Coder Slop Write

Write SLOP Code

按需求生成SLOP代碼。此命令助汝編寫正確、安全、慣用之SLOP代碼。

Usage

/slop-write <description of what you want>

Examples

/slop-write an agent that summarizes articles
/slop-write a data pipeline that filters and transforms user records
/slop-write a batch processor that calls an API with rate limiting

What You Should Do

編寫SLOP代碼時，遵循以下準則：

1. Understand the Requirements

• 輸入為何？
• 輸出為何？
• 是否涉及外部服務（LLM、API、MCP）？
• 是否有性能約束（速率限制、超時）？

2. Apply SLOP Best Practices

Always:

• 以limit()、rate()或有界集合限制所有循環
• 使用emit進行流式輸出
• 以try/catch處理錯誤
• LLM調用定義模式

Prefer:

• 管道優於嵌套循環
• 簡單轉換用lambda函數
• 分支用match表達式
• 有意義的變量名

3. Structure the Code

# 1. Define helper functions first
def process_item(item):
    ...

def validate(data):
    ...

# 2. Main logic
items = get_items()

for item in items with limit(1000):
    result = process_item(item)
    emit result

# 3. Final output
emit(status: "complete")

4. Use Appropriate Patterns

For AI agents:

def agent(input):
    response = llm.call(
        prompt: input,
        schema: {output: string}
    )
    return response.output

result = agent(user_input)
emit result

For data pipelines:

result = data
    | filter(x -> condition(x))
    | map(x -> transform(x))
    | take(limit)

emit result

For batch processing:

for item in items with limit(1000), rate(10/s):
    try:
        result = process(item)
        emit(item: item.id, status: "success")
    catch:
        emit(item: item.id, status: "failed")

For MCP services:

result = service.method(arg1: val1, arg2: val2)
emit result

Code Generation Template

生成SLOP代碼時，按以下格式輸出：

# Description: <what the code does>
# Input: <expected input>
# Output: <what is emitted>

# Helper functions
def helper_function():
    ...

# Main logic
# ... processing code ...

# Output
emit(result: result, status: "complete")

Validation Checklist

呈現代碼前，驗證：

• 所有循環有界（limit、rate或有限集合）
• LLM調用已定義模式
• 危險操作有錯誤處理
• 變量作用域正確
• 輸出使用emit語句
• 無無限遞歸可能
• 字符串插值使用{variable}語法
• 管道正確使用|運算符
• Lambda語法為x -> expression或(a, b) -> expression

Common Mistakes to Avoid

Wrong: Unbounded loop

# BAD
for item in stream:
    process(item)

# GOOD
for item in stream with limit(1000):
    process(item)

Wrong: Missing schema

# BAD
response = llm.call(prompt: "Question")

# GOOD
response = llm.call(
    prompt: "Question",
    schema: {answer: string}
)

Wrong: Silent failures

# BAD
result = risky_call()

# GOOD
try:
    result = risky_call()
catch:
    emit(error: "Call failed")
    stop

Wrong: Incorrect string interpolation

# BAD
msg = "Hello " + name + "!"
msg = f"Hello {name}!"

# GOOD
msg = "Hello, {name}!"

Wrong: Incorrect lambda syntax

# BAD
items.map(x => x * 2)
items.map(lambda x: x * 2)

# GOOD
items | map(x -> x * 2)