Rationale

NO WORK WITHOUT QUESTIONING WHETHER THE WORK IS WORTH DOING

Ask yourself:
- What specific problem does this solve?
- Who experiences this problem and how often?
- What happens if we do nothing?
- Is this a real pain point or a hypothetical one?
- Has the user articulated the PROBLEM or jumped straight to a SOLUTION?

For EACH classification, consider:
- Implementation time (the part engineers estimate)
- Testing time (the part engineers forget)
- Documentation time (the part engineers ignore)
- Review and iteration time (the part engineers deny)
- Maintenance burden going forward (the part nobody thinks about)

Multiply your initial estimate by 2.5. That is closer to reality.

Search order:
1. Does an existing library/package solve this? (npm, pip, crates, gems)
2. Does an existing service handle this? (Stripe, Auth0, Twilio, SendGrid)
3. Is there an open-source project that does 80% of what's needed?
4. Can an existing feature in the codebase be extended instead?
5. Is there a 10% effort path that delivers 80% of the value?

For EACH alternative found:
- What percentage of the requirement does it cover?
- What are its trade-offs? (cost, vendor lock-in, maintenance)
- How mature and maintained is it?

Ask yourself:
- What would a staff engineer challenge about this approach?
- What are the hidden costs nobody is thinking about?
  - Ongoing maintenance burden
  - Cognitive complexity added to the codebase
  - Testing surface area increase
  - Documentation requirements
  - Onboarding cost for future contributors
- What will bite you in 6 months?
  - Scaling implications
  - Security surface area
  - Dependency rot
  - Migration pain if requirements change
- Is this solving a symptom or the root cause?
- Are we adding complexity that could be avoided entirely?

ALWAYS present these options (adapt labels to the specific request):

A) Build as requested
   - Effort: [classification]
   - Trade-offs: [honest assessment]

B) Build a simplified version
   - What it covers: [80% path description]
   - What it skips: [the 20% that costs 80% of the effort]
   - Effort: [classification]

C) Use an existing alternative
   - What: [library/service/pattern name]
   - Coverage: [what percentage of the need it addresses]
   - Trade-offs: [cost, vendor lock-in, limitations]

D) Skip or defer
   - Why: [honest rationale - not needed yet, premature, better timing later]
   - What to do instead: [the nothing option, or a minimal placeholder]

Recommend ONE option with clear reasoning.

digraph rationale {
    rankdir=TB;
    node [shape=box style=filled];

    request [label="User Request Received" fillcolor=lightyellow shape=doublecircle];
    skip_check [label="Skip conditions met?\n(bug fix, trivial, pre-analyzed)" fillcolor=lightyellow shape=diamond];
    pass_through [label="Pass to intent-discovery" fillcolor="#e8f5e9" shape=doublecircle];

    reality [label="1. Reality Check\nIs this genuinely needed?" fillcolor="#e3f2fd"];
    effort [label="2. Effort Analysis\nClassify true cost" fillcolor="#e3f2fd"];
    alternatives [label="3. Alternative Paths\nSearch before building" fillcolor="#e3f2fd"];
    senior [label="4. Senior Engineer Perspective\nHidden costs, 6-month view" fillcolor="#e3f2fd"];
    decision [label="5. Decision Point\nPresent options A/B/C/D" fillcolor="#fff3e0"];

    user_decides [label="User selects option" fillcolor=lightyellow shape=diamond];
    proceed [label="Invoke intent-discovery\nwith validated rationale" fillcolor="#e8f5e9" shape=doublecircle];
    defer [label="Work deferred or skipped\nDocument reasoning" fillcolor="#fce4ec"];

    request -> skip_check;
    skip_check -> pass_through [label="yes"];
    skip_check -> reality [label="no"];
    reality -> effort;
    effort -> alternatives;
    alternatives -> senior;
    senior -> decision;
    decision -> user_decides;
    user_decides -> proceed [label="A or B"];
    user_decides -> alternatives [label="C - research deeper"];
    user_decides -> defer [label="D"];
}