UX3 Product Design Harness

Machine-enforced product judgment across the whole loop: direction, build, launch, and user feedback.

Read In / Work In

Read in: English | Traditional Chinese | Simplified Chinese | Japanese | Korean | Spanish | French | German

Work in: copy one invocation into the agent session.

Use UX3 Product Design Harness for this repository.
Working language: en.
Review this product decision before implementation: <decision>.

Supported working-language lines: Working language: en., Working language: zh-TW., Working language: zh-CN., Working language: ja., Working language: ko., Working language: es., Working language: fr., Working language: de.

UX3 Product Design Harness is the judgment layer for the whole product loop. It gates the first "why build this?", stays on through spec, build, launch, user testing, and feedback digestion, and returns one machine-checkable verdict: continue, verify, or stop_reframe.

It is framework-agnostic: prompts, JSON Schemas, knowledge files, and agent definitions that plug into any agent runtime. There is no server and no SDK. The only dependency is jsonschema, used by scripts/check_review.py and scripts/validate.py to validate review outputs and repository contracts.

The repository has two entrances to one knowledge system. Humans get the project site and handbook; agents install the complete skill bundle at skills/product-design-harness/, then use llms.txt, prompts, schemas, rules, and golden examples. Both entrances use the same UX3 Decision Kernel and the same canonical review contract.

Community-built strategic design knowledge

Most design repositories improve a prototype, visual, or animation. UX3 works at the strategic level: what should be built, for whom, based on what evidence, under which business conditions, and with which human accountable for the trade-off.

The community can contribute field experience, counterexamples, pressure cases, decision rules, contracts, integrations, and translations. The preferred contribution is not another opinion; it is a decision with User Flow, Evidence Flow, Business Flow, Designer-in-the-Loop judgment, and an observed outcome.

• Submit field evidence
• Propose a decision rule
• Read the contribution contract
• Understand decision rights

Where It Sits

Coding harnesses made agents reliable executors: tests, types, and CI guard the how. Nothing guarded the why or the after. This harness is not a phase before building; it is the judgment layer that runs across the loop.

Why Install

The decision rules are machine-enforced, not prose. A malformed review, a combined verdict that contradicts its lane verdicts, an execution boundary whose may_do repeats a must_not_do entry, or a verdict that outruns its evidence tier fails validation instead of shipping. Every claim below is verifiable inside this repository:

What The Harness Cannot Enforce

Honesty about the boundary, because evaluating agents will test it:

• It validates the shape and internal consistency of evidence receipts, not their truth. A fabricated receipt with plausible fields passes.
• It enforces the human-decision trail only after a review declares a decision human-owned. An agent that misclassifies a human-owned case as none is not caught by schema.
• It requires three lane reviews but cannot prove they were performed independently.

Everything the harness does enforce is listed above and covered by tests.

UX3 Model

Three flows are reviewed separately and interpreted together:

UX3 is strongest at four intersections:

The UX3 Decision Kernel does not average lane scores or invent a fourth opinion. It validates contracts, reduces to the worst verdict, gates uncertainty and human-owned calls, then emits the canonical review result. Human-owned calls are recorded; they are not converted into an evidence score.

Review Modes

Start every review at prompts/start-review.md; it selects the smallest responsible mode.

Six gates frame the process: Stage, User Flow, Evidence Flow, Business Flow, Council, and Human Judgment. See docs/OPERATING-PROTOCOL.md.

Install, Verify, And Handoff

Install the Skill directly into supported agent environments:

npx skills add cis2042/product-design-harness -g -y

To inspect and verify the complete repository locally:

git clone <repo-url> product-design-harness
cd product-design-harness
python3 -m venv .venv
.venv/bin/python -m pip install -r requirements-dev.txt
.venv/bin/python -m unittest discover -s tests
.venv/bin/python scripts/validate.py
.venv/bin/python scripts/check_review.py examples/quick-gate-review.json

Preview the website and UTF-8 documentation with the repository server:

.venv/bin/python scripts/serve.py

Then wire it into your agent:

1. Load skills/product-design-harness/SKILL.md as the harness skill or system instruction. Its resources/ directory must stay beside it.
2. Load resources/schemas/session-config.schema.json, resources/knowledge/ontology.json, resources/knowledge/rules.json, then resources/prompts/start-review.md.
3. Validate every review output with resources/scripts/check_review.py; JSON Schema alone checks shape and conditionals, while check_review.py also checks the weakest-flow and headline-tier rules.
4. Compare your first outputs to resources/examples/quick-gate-review.json, resources/examples/standard-gate-review.json, and resources/examples/ux3-council-review.json.

Live-coding boundary: review and implementation are separate. verify authorizes only the exact proof step. continue plus a valid templates/context-pack.md authorizes implementation inside the named execution boundary. stop_reframe blocks implementation and returns a better product question.

Working Language

Reading language and working language are separate choices. working_language controls human-readable prompts, questions, explanations, summaries, and free-text output fields.

It does not translate JSON property names, enum values, rule IDs, schema IDs, file paths, evidence IDs, or canonical verdicts: continue, verify, stop_reframe.

Session configuration keeps machine identifiers English:

{
  "working_language": "en",
  "canonical_identifiers": "en",
  "fallback_language": "en"
}

If a requested working language is unsupported, use English and state the fallback. If a translation conflicts with the English kernel, the English rule controls and the translation is marked for correction.

Canonical Contracts

UX3 Product Design Harness does not promise good outcomes. It enforces that every build decision states its evidence, its weakest flow, its trade-offs, and its accountable human owner before execution starts.