Humans Think in Dimensions, Not Test Cases

Ask a shop owner how time tracking works and they won't give you fifty test cases. They'll say something like: "Workers can clock in early, on time, or late. Shifts can be scheduled or unscheduled. Breaks can be taken, skipped, or not offered."

Those aren't test cases. They're dimensions — axes of variation in the system. Clock-in timing is a dimension with six values. Break outcome is a dimension with four. Shift type is a dimension with three.

The test cases are the intersections. Early clock-in on an unscheduled shift with a skipped break — that's a cell in a matrix defined by those three dimensions. The shop owner didn't think of that specific combination. They described how the world varies. The combinations fall out mathematically.

From Dimensions to Matrix

Six dimensions with four to eight values each produce a full cross-product of roughly 100,000 cells. Most are impossible — an unscheduled shift can't have "round to scheduled time" as its final time source. Many are redundant — the happy path looks the same regardless of which day of the week it is.

The impossible combinations get encoded as constraints:

constraints:
  - when: { transaction_type: transfer }
    force: { invoice_state: not_applicable }
  - when: { transaction_type: tax_payment }
    exclude: { tax_category: [revenue, cogs] }

Strip out the impossible and the redundant and you're left with forty to eighty meaningful intersections. Those are the scenarios worth testing. Not because someone imagined them, but because the dimensions demand them.

The edge cases — where bugs actually live — are the intersections where multiple dimensions modify the output. Early clock-in plus late clock-out means both shift boundaries are adjusted. Break skipped on a long unscheduled shift means a compliance rule fires that nobody thought to test. These combinations are invisible when you think in scenarios. They're obvious when you think in dimensions.

What This Changes for Agents

When an AI agent gets a spec written as scenarios, it implements each one. When it gets dimensions, it can reason about coverage.

I built an accounting app with six dimensions:

# Transaction Type:       income_invoice | income_payment | expense_operating |
#                         expense_contractor | transfer | tax_payment | refund
# Account Type:           checking | savings | credit_card | accounts_receivable
# Tax Category:           revenue | cogs | operating_expense | non_deductible
# Recognition Timing:     cash_basis | prepaid_amortize
# Reporting Period:       current_month | current_quarter | prior_period
# Invoice State:          draft | sent | partial_payment | paid | overdue

The matrix identified forty meaningful intersections. I approved eleven scenarios to start. The completeness check runs after every change. When I add a twelfth scenario — say, a prepaid expense spanning a year boundary — the check catches the new fields, the agent adds verification code, and coverage extends.

The agent doesn't need to be creative about edge cases. The matrix generates them. The human decides which ones matter. The three-way check proves the implementation matches.

Domain Experts Already Think This Way

The people closest to the work use dimensions naturally. They just don't call them that.

An accountant says: "Transactions can be income, expenses, transfers, or tax payments. Each has different tax treatment." Two dimensions with a constraint between them.

An insurance analyst says: "Claims can be auto, home, or liability. Each has deductibles, coverage limits, and exclusions." Three dimensions with domain-specific values.

A logistics operator says: "Shipments can be domestic or international, ground or air, standard or expedited." Three dimensions and a matrix of regulatory requirements.

None of them are enumerating scenarios. They're describing how their world varies. The dimensional model captures that knowledge in a structure an agent can navigate — and a completeness check can verify.

The Spec Extends Itself

When a new dimension is added — a state adds daily overtime rules on top of federal weekly overtime — the matrix gains an axis. All existing scenarios get plotted. New gaps appear. The human approves the important ones. The golden values grow.

When a bug surfaces in production, the fix is: which dimensions intersect here? Map it to coordinates. The matrix shows no scenario covers that cell. Add one. The spec grows from discovered bugs, not from imagination.

Over time, the spec converges on completeness. Not because someone thought of everything — because every gap that matters eventually gets found, mapped, and filled. The human's job shifts from "think of test cases" to "describe how the world works." That's a skill domain experts have been practicing their entire careers.

---

This is part of a series on spec-driven development with AI agents. Previous: Agentic Engineering Is Pattern Engineering. Next: Bugs Are Missing Scenarios.