A build isn't "done" because it compiles. Kinetech runs every app through a fixed set of gates — each proves a specific thing, and together they add up to an app you can actually ship. Below: every gate, what gets done and why it protects the complete build. Nothing is presented as ready until all of them are green.
🟢
Fail-closedIf a gate can't be PROVEN, it counts as failed — never "probably fine." Silence doesn't pass.
📐
Six dimensionsPlan · Look · Act · Perform · Document · Operate — the Definition of Done.
🤖
The agent runs themThe app is built, run in Docker, and driven by the agent — never operator homework.
Plan · before a line is built
Decide what "good" means up front
Every later gate measures against decisions made here. Skip the plan and the tests have nothing to check.
Mockup plan
What: a per-page wireframe of design intent for every screen.
Why: the app is built TO a design, not improvised — and the visual gates get a baseline to judge against.
Ratified permissions
What: every role's can / can't, confirmed AND ratified — the persona × flow matrix, positive and negative.
Why: security and per-role testing both read this. Unratified means nobody agreed what users may do.
Stories = test specs
What: a story per role on the Mendix Epics board — setup / steps / expected / acceptance / boundary + the linked test.
Why: the plan IS the test plan. "What we promised" and "what we tested" can't drift apart.
Look · the way it LOOKS
Prove it looks designed, not generated
"It builds" says nothing about whether anyone wants to use it. These catch cramped, edge-to-edge, off-brand, dead-button regressions.
Branded login + nav icons look
What: the first screen is on-brand (logo-derived theme, a chosen login design); the nav rail has real icons.
Why: the default Mendix login is plain; a branded shell sets the tone before anyone signs in.
Screenshots — every screen
What: the agent drives the app and captures EVERY screen, including every editor — no sampling.
Why: you can't judge what was never looked at. Sampling is how a broken editor slips through.
Accessibility (0 serious)
What: an axe audit on each screen; zero serious violations to pass.
Why: accessible by default — and a real proxy for clean, well-structured UI.
Design critique ≥ threshold
What: a vision model scores each screen against the UI standards (gutters, density, primary action, hierarchy).
Why: turns "looks like garbage" into a number with a bar — below it is a blocking gap.
UI-quality guards (deterministic)
What: model-level checks: Cancel/X closes popups, no text-only dashboards (charts via ReChart), computed fields read-only.
Why: read from the model, so a regression can't fool the screenshots — catches dead buttons and lifeless dashboards.
Act · the way it ACTS
Prove it actually works — driven, not assumed
The heart of the set: real interactions on a running app, for every role, both directions.
mx-check (builds clean) act
What: the real Mendix consistency check (Studio-Pro-equivalent), zero errors.
Why: the authoritative "the model is valid" — stronger than the SDK's lying gate.
Unit + driven user tests
What: microflow unit tests, plus user-tests that DRIVE the real task — pick the catalog item and assert it autofills, change a quantity and assert the total recomputes, save, confirm it persisted.
Why: "open the page and check text rendered" is not a test. Driving catches the editor that silently does nothing.
Per-role coverage — both ways
What: every role's full access map exercised; forbidden controls proven UNreachable.
Why: the negative side catches over-exposure — a customer seeing a staff menu — that happy-path testing never would.
Security + vulnerability scan
What: access-control probes against the running app + a static / marketplace scan.
Why: multi-tenant row isolation must hold at PRODUCTION security, not just demo — proven, not assumed.
Seeded test data
What: the app is populated so the drive (and reviewers) see a real, full app.
Why: empty screens hide layout and binding bugs; a seeded app shows the truth.
Perform · the way it PERFORMS
Prove it holds up
Snappy in a demo means nothing under real load. These measure both.
Performance timings perform
What: page-load and action timings captured during the drive.
Why: surfaces the slow page or N+1 microflow before a user feels it.
Load test (k6)
What: concurrent traffic against the running app — error rate < 1%, p95 within budget.
Why: the legitimate "will it survive launch day" check; results posted to the Console.
Document · usable & maintainable
Prove a human can use it (and the next dev can read it)
Two audiences: the end user who operates it, and the future developer (and the AI) who extends it.
End-user visual guide document
What: an auto-generated how-to with screenshots per workflow.
Why: users get a real guide instead of "figure it out"; doubles as proof every workflow was walked.
In-model documentation (100%)
What: every authored element — entity, attribute, microflow, page — carries a documentation string.
Why: the model is the source of truth. The Console, sprint notes, knowledge graph and in-app agent are generated FROM it.
Operate · after it ships, every sprint
Prove you'll know before users do
Gates that keep working after go-live — and keep the experience honest sprint after sprint.
Monitoring + log triage operate
What: health monitoring, Mendix Cloud alerts routed to your facility, real-time / remote logs auto-triaged.
Why: find what went wrong before the end user reports it — auto-react instead of firefighting.
Full-UX-per-role audit — every sprint
What: the DEEP audit drives EVERY page for EVERY role, screenshots + scores each, into a recognized UX scorecard (ISO 9241-11). Must be FRESH within the sprint.
Why: the per-build fast checks miss role-specific UX drift; forcing the deep audit each sprint keeps quality from eroding.
READY
The verdict — not a claim
"Ready for testing/review" is a gate. The app is presented as ready only when every blocking criterion is green at once — and the deep UX audit ran THIS sprint. If any one can't be proven, the answer is: not ready.
Fail-closed by design. Never run, stale, or unprovable → the gate says no. That's the whole point: "ready" means it was proven ready, every dimension checked, every single time.
