---
title: "simplest thing"
---
# 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 →](/run-ai-locally/02-prompting/05-one-shot-prompts/)**