Prompts Are Programs

The Formula

Every prompt you've ever written follows this structure. Template defines how to think. Context defines what to think about. Output is the novel result.

This isn't metaphorical. It's literal. The template is reusable—you can apply it to any context. The context is unique to this instance. The output is only possible because both exist together.

Where Attention Falls

Language models don't distribute attention equally. Transformer architectures have positional bias: top and bottom get more focus. Middle content—even if critical—gets statistically less attention.

Sandwich technique: Put critical constraints at TOP and BOTTOM. Never bury your most important instruction in the middle, no matter how well you explain it.

Citation: Liu et al. (2023) Lost in the Middle: How Language Models Use Long Contexts arXiv:2307.03172

Token Density

Whitespace, prose, and formatting all cost tokens. The same idea expressed densely uses 3-5x fewer tokens. Denser tokens = more context available for the model to use.

Example:

def get_user(id: int) -> User:
    """Cache 5min, raise NotFound"""

The get_user function accepts an integer ID parameter
and returns a User object. Results are cached for 5
minutes. Raises NotFound if the user doesn't exist.

Load, Chain, Compose

There are only three things you can do with a prompt. Everything else is a combination of these three operations.

1. Load

Bring artifacts into context—files, git status, command output, external data.

<context>
  <file path="./src/auth.py"/>
  <command>!`git status --short`</command>
</context>

2. Chain

Output of step A becomes input to step B. Preserve state across steps.

Step 1: Analyze requirements → requirements.md
Step 2: Load requirements.md → Generate plan → plan.md
Step 3: Load plan.md → Implement with full context

3. Compose

Combine a template with context to produce a specialized output.

Template: "Review code for $CRITERIA"
Context:  CRITERIA=security, FILE=auth.py
Output:   Security review of auth.py

XML Structure

XML tags create clear boundaries between objective, context, requirements, constraints, output, and verification. The model respects structured boundaries more reliably than prose.

6-Tag Pattern

<objective>What and why</objective>
<context>Background, files to load</context>
<requirements>Specific instructions</requirements>
<constraints>What to avoid and WHY</constraints>
<output>Where to save, format</output>
<verification>How to confirm success</verification>

Tag Selection by Complexity

Full Template

<objective>
Refactor the authentication module to use industry-standard bcrypt
instead of custom hashing, improving security and maintainability.
</objective>

<context>
<file path="./src/auth.py"/>
<file path="./tests/test_auth.py"/>
<current_password_hash>custom_sha256 with salt rotation every 30 days</current_password_hash>
</context>

<requirements>
1. Replace custom hash with bcrypt
2. Maintain backward compatibility for existing hashes
3. All existing tests must pass
4. New tests for bcrypt edge cases
</requirements>

<constraints>
- No new external dependencies (bcrypt must already be in requirements)
- Cost factor must be ≥12
- Never log passwords, hashes, or salt
- Migration path for existing users
</constraints>

<output>
Refactored auth.py with clear comments at hash/verify boundaries.
Updated test_auth.py with new test cases. Provide migration guide.
</output>

<verification>
All tests pass, including new bcrypt tests.
Manual check: old hashes still verify, new hashes use bcrypt.
No new secrets in logs.
</verification>

The Pattern Catalog

These are the patterns that work. Not because they're trendy—because they're grounded in how transformers process language.

Foundational Patterns

Advanced Patterns

ReAct (Reasoning + Action)

THINK: What should I do?
ACT: Do specific action
OBSERVE: Check result
→ Repeat until done

Citation: Yao et al. (2022) ReAct: Synergizing Reasoning and Acting in Language Models arXiv:2210.03629

Tree of Thoughts

1. Generate 3 approaches
2. Evaluate pros/cons each
3. Choose best, execute

Citation: Yao et al. (2023) Tree of Thoughts: Deliberate Problem Solving with Large Language Models arXiv:2305.10601

Meta-Prompting

Use AI to generate prompts for other AI to execute. Separates analysis from execution—one model does clarification, another does the work with fresh context.

You (vague idea) → AI #1 (generates detailed prompt) → AI #2 (executes with full attention)

Why it works: AI #1 asks clarifying questions, adds structure, defines success criteria. AI #2 gets clean, specific instructions with full attention. No context wasted on negotiation.

Citations

• Wei et al. (2022) Chain-of-Thought Prompting Elicits Reasoning in Large Language Models arXiv:2201.11903
• White et al. (2023) A Prompt Pattern Catalog to Enhance Prompt Engineering with ChatGPT arXiv:2302.11382

Making Context Survive

Context windows fill up. Conversations end. Projects span weeks. These three files are how you maintain coherence across boundaries.

Spec Folder Pattern

spec/
├── KNOWLEDGE.md   # WHY - Decisions, constraints, patterns
├── SPEC.md        # WHAT - Requirements, acceptance criteria
└── PLAN.md        # HOW - Phases, tasks, verification

Surgical Loading

Load based on what you're doing, not everything at once:

Context Handoff Template

<original_task>
What was requested at the start
</original_task>

<work_completed>
Files created/modified, decisions made, blockers resolved
</work_completed>

<work_remaining>
Specific next tasks with file paths
</work_remaining>

<attempted_approaches>
What failed and why - avoid repeating mistakes
</attempted_approaches>

<critical_context>
Gotchas, assumptions, constraints discovered in the work
</critical_context>

<current_state>
What's finalized vs still draft. Which files are safe to change.
</current_state>

Save this as HANDOFF.md or CONTEXT.md. Load it at the start of your next session.

Quick Reference

Bookmark this section. Use these tables every time you write a prompt.

Attention Positioning

Core Operations

Token Optimization

Patterns to Use

Persistence Files

Common Mistakes

These happen in almost every project. Learn to spot them early.