Groceries ordered
by contracts alone

The setup

A private GitHub repo with no software, no database, and no programming language — just structured files that any AI agent can read:

reeves-grocery/
  contracts/
    shopping-list.schema.json     # what a valid order looks like
    meal-plan.schema.json         # what a valid meal plan looks like
    pantry-update.schema.json     # how to update what's on hand
  preferences/
    dietary.yaml                  # PSMF-influenced, high protein, lean
    cooking.yaml                  # batch cook, low prep time
    shopping.yaml                 # store brand default, budget-conscious
    goals.yaml                    # $500 shelf-stable reserve target
  pantry/
    current.md                    # what's on hand (hints, not ledger)
    reserve.md                    # shelf-stable buffer

An AI agent — in this case Perplexity Computer — reads the contracts and preferences, produces a conforming shopping list, and places the order. No agent framework required. No tool calls. The agent uses whatever capabilities it has (browsing, clicking, typing) to fulfill the contract.

The contract

This is the entire specification. The AI reads this and knows what to produce.

{
  "title": "Shopping List",
  "purpose": "Produce a weekly grocery order for one person.
    The list will be submitted to a store's ordering system —
    every item must be a real, purchasable product.",

  "context": "Read preferences/dietary.yaml for what this person
    eats. Read pantry/current.md for what's on hand. Read
    pantry/reserve.md to check the shelf-stable buffer.",

  "constraints": [
    "Protein items dominate — PSMF-influenced diet",
    "Reserve restocks when pantry/reserve.md looks thin",
    "Quantities in purchasable units (3 lbs, not 0.5 cups)",
    "Store brand default unless specified",
    "Optimize for protein per dollar"
  ],

  "required": ["date", "store", "items"],
  "items": [{
    "name": "boneless skinless chicken breast",
    "quantity": "5 lbs",
    "category": "protein",
    "reserve_restock": false
  }]
}

The preferences

The contract says "read preferences." Here's what it finds:

dietary_lean: PSMF-influenced
  # High protein, very low fat, very low carb
  # Lean protein is the center of every meal

priorities:
  - high-protein
  - lean-affordable-protein
  - low-maintenance-prep
  - budget-conscious

# Staples: chicken breast, ground turkey,
# tuna, egg whites, green vegetables

brand_strategy: store-brand-default
  # Prefer generic unless specified

fulfillment: null
  # pickup | delivery | in-store

prefer_brands: []
avoid_brands: []

What actually happened

On March 29, 2026, the agent (Perplexity Computer) cloned the repo, read every file, and understood the entire system in under two minutes. It asked three questions: what store, what scope, anything specific. Answers: Walmart delivery, weekly + reserve restock, dark chocolate.

It built a 7-day PSMF meal plan hitting ~160g protein/day at 800-850 calories. Then it generated a 64-item shopping list, opened Walmart.com in the browser, and added everything to the cart in four batches. The human reviewed, removed 2 items, and placed the order. Express delivery, 80-110 minutes.

The actual shopping list

The agent's own assessment

After completing the order, the agent wrote observations into the repo's log. These are excerpts:

Contracts vs skills: the numbers

We built this system both ways. First as a skills-based forge (shopping-forge) with step-by-step instructions. Then as a contracts-based repo (reeves-grocery) with schemas and data. Here's what happened:

64% less code. But the real difference isn't size — it's durability. The skills approach has 4 files totaling 705 lines of step-by-step instructions: "Step 1: read the profile. Step 2: generate a meal plan. Step 3: check Omni for past orders." Every model upgrade makes parts of those instructions redundant. Every store website change breaks the cart orchestration skill.

The contracts approach has 3 schemas that say what a valid shopping list, meal plan, and pantry update look like. The AI figures out the steps. A smarter model produces a better list from the same contract. The contract hasn't changed since it was written.

Why contracts are more accurate

A skills file can't anticipate every store's UI, every out-of-stock scenario, every substitution logic. It prescribes a fixed procedure. When reality doesn't match the procedure, it fails.

A contract says: "produce a list where protein dominates, quantities are purchasable, and store brand is default." The AI applies this to whatever store it's looking at, whatever is in stock, whatever the current prices are. It reasons about the goal, not the steps. That's why it handles edge cases the skills file never imagined.

The guardrails

Three rules govern the entire repo:

1. No software. If a file needs a parser to be useful, it doesn't belong here.
2. Human-readable above all else. A person can open any file and understand it without tools.
3. Git is the audit trail. No timestamps in files. Git history shows what changed and when.

Try it yourself

We published an example repo you can fork. Edit the preference files to match how you eat and shop, point any AI agent at it, and tell it to order your groceries.

Read more: Contracts, Not Skills · Minimum Viable Data