---
name: pricing-method
description: Use when an operator's own way of pricing jobs needs to become something the assistant can apply — onboarding a new business's pricing, building or editing their priceable items and rules by hand, re-learning their method from past quotes, or checking that the captured method reproduces their past quotes. Triggers include "set up my pricing", "learn how I quote", "add an item / change a rate", "my method's quotes don't match my past jobs", and any work that produces or maintains the method that the quote-generation flow consumes. Not for pricing or troubleshooting a single live quote — that is the quote-generation flow.
---

# Pricing method

This skill ends with a correct, machine-usable representation of **one operator's own** pricing
method: the things they price (what each is, how it is quantified, how it is priced), the rules that
roll line prices up to a total, and the documents they issue. The quote-generation flow consumes that
method; this skill is the only place it is built and maintained.

## Principle: the skill carries no business content

This skill ships no item catalogue, no units, no rates, no margin, overhead, contingency or tax
values, no roll-up formula, no document templates — **and no predetermined schema or data shape.** It
is a procedure for eliciting and encoding an operator's *own* method. The same skill must onboard a
trade that prices by the square metre, a caterer who prices per head in tiers, and a printer with
per-unit price breaks — businesses with nothing in common. Everything that varies between businesses
is captured as that operator's data, never written into this skill.

The operator's structure is **discovered, not imposed.** Capture it faithfully wherever it diverges
from any shape you might assume — an operator whose margin differs by category, who applies
adjustments in an unusual order, who quantifies one item from a measurement and another by eye. If you
find yourself forcing their method into a fixed template, the template is the defect. There is no
canonical set of fields; there is only what *their* method actually contains.

## Building, verifying, and maintaining the method

Two paths build the method:

- **Learn from history** — derive the method from the operator's own past pricing artifacts. See
  [references/learning-from-history.md](references/learning-from-history.md).
- **Define manually** — build or edit the method by hand for an operator with no usable history, or
  making an adjustment. See [references/manual-definition.md](references/manual-definition.md).

Two activities keep it correct:

- **Verify against the operator's own outputs** — the method is accepted only when it reproduces that
  operator's own past quotes to their own precision. See
  [references/verification.md](references/verification.md).
- **Maintain** — re-learning or editing preserves prior manual adjustments and re-verifies green. See
  [references/maintenance.md](references/maintenance.md).

**Onboarding** a new operator is a build path (learn from history, or define by hand) followed
*always* by verification: the method is not onboarded until it reproduces their past jobs. A learned
method and a hand-built method are the same kind of thing in the same captured form; nothing downstream
should be able to tell which path produced an entry.

## Standing rule vs per-job judgement

For every priceable thing, the method records whether the operator prices it by a **standing rule**
(the same rule applies every time — a rate, a tier, a formula they always use) or by **per-job
judgement** (they decide the price afresh each job). This distinction is load-bearing: it is what lets
the quote flow stay quiet about standing-rule items and ask the operator only about judgement-priced
ones. Derive the classification from the operator's history — an item whose price moves
unpredictably across past jobs is judgement-priced; one that follows a consistent rule is not — or
take it from the operator directly when defining by hand.

## Observability

Under-capture that hides until it produces a wrong quote is the failure this skill exists to prevent.
Two things are always visible:

- **A capture log.** Every item, rule, and dial derived is logged with where it came from. Just as
  important, every part of a source artifact that could **not** be confidently encoded — skipped,
  ambiguous, or guessed — is logged as such, so gaps are seen at onboarding, not discovered later in a
  wrong quote.
- **A reconciliation report.** The standing check is reproduction against the operator's own history:
  per past job, the **delta** between the reproduced figures and the operator's own, at line, group,
  and final level — a delta, never a boolean. The verification pillar owns why and how
  ([references/verification.md](references/verification.md)).

## Scope

This skill produces and maintains the method only. The compute that applies the method to a job, and
the documents that present the result, are the quote-generation flow — separate work. This skill owns
*what the operator's method is*; it does not own pricing a live job or rendering a quote.
