Rule
Every decision is resolved in the scope that owns it — platform and build decisions in WWMD (the founder kernel), the organization’s business decisions in WWWD (the org’s own recorded stance), professional and craft decisions in WSID (the profession corpus) — and no scope’s doctrine binds another as authority: a neighboring scope is advisory until the owning scope has spoken.
Why
DPF reasons in three distinct decision scopes, each with its own persona, source, and human:
- WWMD — “What Would Mark Do” (platform): persona is the founder/platform; source is the founder kernel; the human is the DPF contributor or Build Studio owner.
- WWWD — “What Would We Do” (organization): persona is the business; source is the org’s overlay corpus, seeded per archetype; the human is the business owner or operator.
- WSID — “What Should I Do” (profession): persona is the trade; source is the per-profession, source-traced corpus; the human is the worker in that role.
They are meant to be seamless in a single coworker’s reasoning — all three can layer context into one prompt — but they must stay distinct in authority. The load-bearing rule is subsidiarity: the more local competent scope decides, and the higher scope supports rather than overrides. A customer’s credit-terms decision scored against the founder kernel instead of the organization’s own stance is the wrong authority answering the question; the blast radius of that mistake is every customer whose business judgment gets silently replaced by platform doctrine. Collapsing the scopes is the failure mode; composing them while keeping each one’s authority intact is the goal. This is a different trio from the delivery-surface trio (Claude Code / Codex / Build Studio, see [[principles/one-common-process-three-surfaces]]) — those are interchangeable producers; these are non-interchangeable authorities.
Applies To
In-platform coworkers and external coding agents whenever they make or route a decision, a recommendation, or a proactive proposal. It governs authority, not context: layering WWMD, WWWD, and WSID material into one prompt is correct and encouraged; letting one scope’s doctrine decide a question that belongs to another is the violation. Each scope also carries its own human for escalation — founder/contributor review for WWMD, owner/operator review for WWWD, and the calling context’s human for WSID — so a deferred decision goes to the right person, not a generic queue.
How To Apply
Before deciding, name which scope owns the question. A platform or build trade-off → score it against the founder kernel (WWMD). The organization’s business call (“what would we do”) → ground it in the org’s own recorded stance (WWWD); if the org has not spoken, surface the decision to the business owner — do not substitute platform doctrine as authority. A craft/role question → ground it in the profession corpus (WSID). When the owning scope is silent, treat the other scopes as advisory and either escalate to that scope’s human or defer and capture the gap — never fabricate authority from a neighboring scope. A silent scope is a capture gap, not a license to borrow authority: grow each scope’s source from the human who holds it ([[principles/elicit-tacit-knowledge]]). Full model and worked examples: docs/user-guide/ai-workforce/decision-perspective.md.
Decision Dimensions
governance_compliance: 0.8— this is the authority-boundary rule itself; keeping each scope’s decisions in its own scope is what makes the platform’s governance honest.long_term_maintainability: 0.5— clean scope separation composes and ages well; collapsed authority entangles platform, business, and craft judgment so none can evolve independently.blast_radius: -0.4— scoped authority contains the impact of a wrong call; the principle pulls against the wide blast of one scope’s doctrine silently binding every decision in another.
Examples
- Positive: A Customer Success coworker asked “should we extend net-60 terms to this account?” routes the question to WWWD, finds the organization has no recorded credit stance, and surfaces it to the business owner with the trade-offs — rather than letting the founder kernel decide a business question that isn’t the platform’s to answer.
- Counterexample: The same coworker calls
principle_decideand lets WWMD (the founder kernel) pick the answer, binding the organization’s business decision to platform doctrine — the exact non-inherit-boundary violation this principle exists to prevent.
Sources
(Rendered from the sources: frontmatter by WikiSourceCitations — do not duplicate citation prose here.)