04 — Spell #2: The Simplest Thing

The Problem

AI models love complexity. Given a choice between a simple solution and a clever one, they’ll often pick the clever one. They’ll propose databases when a text file would work. They’ll suggest frameworks when a script would do. They’ll over-engineer.

This is a real problem in software engineering too. There’s a principle for it:

YAGNI — “You Aren’t Gonna Need It”

It means: don’t build features you don’t currently need. Do the simplest thing that works.

The Spell

When the model asks a design question and you’re not sure what to pick, respond with:

I’m not certain, but we should always do the simplest thing.

That’s it. Here’s a real example from building our prompt runner:

Question from the model:

“Regarding the storage of the prompts, the generated code, and the execution results: Would you prefer the system to store everything in a simple folder structure on your local disk (e.g., each run creates a new folder containing the prompt, the .py file, and a log file) or would you prefer a single database file (like SQLite) that keeps a structured, searchable log of every run?”

Our response:

I'm not certain but we should always do the simplest thing.

The model immediately understood: folder structure. No database. No complexity. Simple files on disk.

Why This Works

This spell works for two reasons:

1. It’s a recognized engineering principle. The model has seen “YAGNI” and “simplest thing” in its training data. It knows what you mean.
2. It overrides the model’s bias toward complexity. Most training data shows sophisticated solutions — blog posts about Kubernetes, tutorials about React, documentation for SQLite. The model defaults to “professional.” You’re telling it to default to “simple.”

When to Use It

Use this spell when:

• The model proposes a solution that sounds complicated
• You don’t understand the trade-offs between options
• You’re early in a project and want to keep things simple
• You’re prototyping and want to move fast

Don’t use it when:

• The model is asking about something genuinely important (like security)
• You have a specific requirement that demands complexity
• The “simple” solution would be dangerous (e.g., skipping error handling in a script that deletes files)

Real Example: Avoiding Python Dependencies

When the model generated a Python script requiring pip install, we pushed back:

I've heard that Python is hard to get working. Do you have a simpler
solution that doesn't involve installing stuff? I'm on a Mac.

The model switched to a bash script — zero dependencies, zero installation, just save-and-run. That’s the power of demanding simplicity.

What You’ve Learned

• YAGNI (“You Aren’t Gonna Need It”) is the software engineering version of “keep it simple”
• Telling the model to do the simplest thing prevents over-engineering
• Complex solutions have more failure points — simple ones just work
• You can always add complexity later when you actually need it

Next: 05 — One-Shot Prompts →