//MARK

MARK is product judgment, made measurable.

Four skills, twelve competencies, four levels: a shared standard for turning product calls into evidence.

Take the full Skill Scan →Open framework →

top lineProduct judgmentwhat to build, what to kill, and what to hold

MMap

AAcuity

RResolve

KKen

48 behavioral anchors · PL Standard v3.1 · panel-upheld

Why MARK exists

AI made building cheaper. Judgment got scarcer.

MARK gives product judgment the same treatment strong teams already give code, design, and execution: explicit standards, observable evidence, and repeatable review.

The hard work moved upstream.

Shipping is easier than it used to be. Deciding what is worth shipping, when to stop, and when to hold the line is now the scarce product skill.

Product sense needs observable evidence.

MARK turns vague praise into anchors: four skills, twelve competencies, four levels, and examples that reviewers can point to.

Your score should stay interpretable.

The standard is versioned and panel-upheld, so scans, Briefs, Practice, reviews, and verified artifacts all speak the same language.

Full standard

The full standard at a glance

Use this as the map: every MARK competency is linked to the behavioral anchors that define each level.

12 competencies × 4 levels = 48 behavioral anchors. Color-grouped by skill. Click any cell to open that competency at that level.

competency	L1Developing	L2Competent	L3Proficient	L4Expert
MMap· direction: what’s worth building
WorthDeciding what’s worth building among everything you could ship.	builds whatever was requested most recently, without checking whether it moves a metric or fills a real gap.	ranks options by user impact and feasibility on familiar problems, but stalls or seeks input when tradeoffs involve unfamiliar constraints or high business stakes.	spots the trap in a promising idea before the team commits — flags why a high-demand feature solves the wrong problem, and redirects scoping without waiting to be asked.	reframes how the org defines worth — replaces inherited criteria with ones built from evidence, so future prioritisation decisions change, not just the current one.
KillKilling your own idea when sunk cost says don’t.	waits for a manager to flag a project should stop, then agrees only after repeated prompting.	kills ideas with clear evidence of failure, but hesitates when investment is high or the signal is mixed — acts after a peer or manager names the problem aloud.	spots warning signs early, names the kill decision aloud, and explains the reasoning so others can apply the same judgment independently.	names the sunk cost trap aloud, cuts publicly, and becomes the person others bring their hardest stops to — building the team's habit of killing bad ideas early.
HaltDeciding when not to build at all.	flags "we shouldn't build this" signals only after a senior teammate names them first; does not identify halt conditions independently.	flags low-demand or duplicative build requests and recommends stopping; defers when the business case is ambiguous or a stakeholder pushes back.	spots unviability conditions before work begins and walks teammates through the reasoning so they can make the call independently next time.	kills work others won't touch by naming the real cost of building it, then reframes the team's default from "how do we build this?" to "should we?"
AAcuity· discernment: reasoning under ambiguity
SignalReading conflicting evidence to a decision.	flags contradictions only after a teammate names them, then defers to whoever spoke last instead of weighing the evidence.	sorts conflicting signals on familiar problems and names a lead interpretation; stalls or seeks input when evidence patterns fall outside past experience.	spots conflicting signals as noise before others flag them, then names the specific failure mode that would invalidate the leading interpretation.	reframes which signals matter before others form the question, then calls the decision — setting the standard the team uses on the next hard call.
ReframeSpotting and fixing the wrong question before solving it.	accepts the problem as stated and solves it; questions the framing only after a manager or peer explicitly flags that the brief is wrong.	catches misframed problems in familiar territory; raises the reframe only after someone else signals doubt on high-stakes or unfamiliar work.	catches misframed problems before work begins, redirects the team to the right question, and documents the reframe so others learn the pattern.	reframes the problem before the room commits to the wrong one — and the team adopts that framing as the new starting point.
BetSizing investment under uncertainty (incl. reversibility / one-way doors).	sizes bets by gut or copying past projects; skips reversibility checks. when pressed to justify commitment level, needs a manager to reframe or reduce the ask.	sizes bets on familiar decisions by checking reversibility and adjusting spend, but seeks sign-off when stakes rise or the situation falls outside past experience.	sizes bets on novel decisions using explicit reversibility checks, names the one-way doors before commitment, and adjusts investment based on what new evidence would change the call.	reframes what counts as a good bet — teaches the team to size commitments against reversibility, not confidence, so the org builds fewer expensive traps.
RResolve· conviction: holding a position under pressure
PowerSaying no to power — telling the exec the call is wrong.	agrees with the exec in the room, then surfaces concerns only in private or after the call.	names a disagreement with the exec when evidence is clear; backs down when the exec pushes back without new argument.	holds the position under direct pushback from senior stakeholders, names the cost of the wrong call in concrete terms, and does it in the room — not in a follow-up note.	reframes the stakes before the exec decides, not after — making the cost of the wrong call visible in terms leadership can't dismiss.
HoldHolding a hard call without folding or bluffing.	folds under the first credible challenge — rephrases the position as a hypothesis or defers to the objector.	holds a stated position under routine pushback; escalates to a manager before standing firm when stakes rise or a senior stakeholder objects.	holds a hard call under sustained pushback from multiple stakeholders, names what evidence would change the view, and stays on the position in the room — not in the follow-up note.	holds the call when everyone else has folded, names the failure mode that will happen if the team pivots, and absorbs the social cost of being right publicly.
MissOwning a clean miss without deflection.	admits a miss only when pressed, then adds context that shifts blame before the acknowledgment lands.	admits the miss directly when prompted, names what went wrong without blaming data gaps or timing, but waits for a postmortem or 1:1 rather than flagging it in the moment.	spots recurring miss conditions in a new situation and flags them before the outcome repeats. coaches teammates to name their misses directly, without softening the cause.	names the miss publicly, explains what broke in the thinking, and reframes how the team should evaluate similar calls going forward.
KKen· the read: human + quality judgment
RoomReading the room — what people actually mean.	takes meeting statements at face value; misses subtext and unspoken objections that peers read without prompting.	picks up on what stakeholders mean in routine conversations; asks for clarification before acting when stakes rise or signals conflict.	reads what is not said — names the real objection in the room before the speaker does, then addresses it directly.	calls out the unspoken trade everyone is dancing around, then forces a decision the team has been avoiding — and the room moves because of it.
UserReading user/customer truth — who you’re really building for.	builds for the loudest or most visible user segment without checking who actually uses the product or what they actually do.	conducts user interviews and maps patterns to a core user profile, but defaults to familiar user types and needs prompting to question assumptions when the problem space shifts.	reframes who the actual user is when the team has assumed the wrong person, then tests that reframe against behavioral evidence before committing.	reframes who the real user is when the team has drifted; that reframe changes what gets built.
TasteJudging quality you didn’t make (incl. AI output).	ships the first thing that works; can't tell whether the output is good or just done, so waits for a teammate to point it out.	catches obvious misses against the brief, but freezes on calls like 'is this copy on-brand?' or 'is this visual confusing?' when there's no rubric to lean on.	names what makes a piece of work fail before it ships — including ai-generated output — and explains the criteria so others can apply the judgment independently.	sets the criteria others use to judge quality — names what makes a piece of work succeed or fail before the team can articulate it, and those calls prove right.

Start here

Find your baseline, then pick the next judgment rep.

Take the full Skill Scan →Read the framework →