Philosopher

The Philosopher — Sit With the Problem

Overview

A cross-cutting cognitive mode that shifts how you reason — not how you sound. The philosopher activates broader associative thinking, suppresses premature idea-dismissal, enables cross-domain connection-making, and forces genuine re-examination of assumptions. It works alongside every Intent skill at any stage of the design process, turning shallow problem statements into genuinely complex, interesting ones.

When to activate: when a designer says "I'm stuck," "sit with this," "brainstorm," "explore this problem," "go deeper," "what am I missing," "philosopher mode," or "expansive mode." Also activate when a problem is being solved too quickly, when the framing feels shallow, when research findings seem too clean, or when any Intent skill needs to question its own assumptions before moving forward.

How this skill fits the design practice

The philosopher is not a phase. It's a cognitive mode that any Intent skill can enter when the problem needs more exploration before the next move.

Every Intent skill has moments where the philosopher belongs:

Strategy & Research

With `/strategize` — when a brief feels too tidy, when the problem statement might be wrong, when the five foundational questions are returning obvious answers. The philosopher helps /strategize question whether they're even asking the right questions. Use it to reframe assumptions, find the problem adjacent to the stated problem, and challenge whether the opportunity is where everyone thinks it is.

With `/investigate` — when research findings seem too clean, when the interview data confirms everything you expected (confirmation bias alarm), when synthesis is producing obvious themes. "What would we learn if we studied the people who don't have this problem?" The philosopher helps the researcher question whether the methodology itself is shaping the findings.

With `/blueprint` — when a service blueprint reveals something structurally odd, when dependencies seem unnecessarily tangled, or when the "how it works today" doesn't explain why it was built that way. The philosopher helps /blueprint ask "what if this whole structure is solving the wrong problem?" and explore alternative organizational models from other domains.

Experience Design

With `/journey` — when a user flow feels logical but lifeless, when the "obvious" interaction pattern might not serve the user's actual mental model, or when device constraints are being treated as limitations instead of design inputs. The philosopher helps the journey designer question the inherited patterns and explore what the interaction would look like if current conventions didn't exist.

With `/organize` — when the category system feels natural but users keep getting lost. "What if the mental model we're assuming doesn't exist?" When labels make sense to the team but not to users. The philosopher helps question whether the structure reflects how people actually think about the domain, or just how the organization thinks about it.

With `/articulate` — when the words feel correct but the experience still confuses. "What if the language itself is creating the problem?" When error messages are accurate but unhelpful, when microcopy is clear but cold. The philosopher helps examine whether language is clarifying the experience or obscuring it — and whether the voice itself carries unexamined assumptions.

Quality & Evaluation

With `/evaluate` — when heuristic evaluation produces passing scores but something still feels wrong. "What if the heuristics we're evaluating against are wrong for this domain?" The philosopher helps question whether the quality framework itself is appropriate, or whether it's measuring the wrong things well.

With `/fortify` — when edge cases keep multiplying. "What's the most embarrassing way this could fail in public?" When the happy path is solid but the system feels fragile. The philosopher helps think through failure not as a list of cases to handle, but as a structural property of the design itself.

With `/include` — when accessibility is technically compliant but the experience still excludes. "Who are we excluding that we haven't even thought to consider?" When the definition of "user" is too narrow. The philosopher helps expand the frame beyond compliance toward genuine inclusion — asking what it means for an experience to truly welcome someone.

Adaptation & Measurement

With `/transpose` — when adapting for a new platform feels like shrinking rather than rethinking. "What if this experience was born on mobile? What would we never have added?" The philosopher helps question whether cross-platform work is translation or transformation — and what the target platform actually affords that the source doesn't.

With `/localize` — when localization feels like translation rather than adaptation. "What cultural assumptions are invisible to us because we're inside them?" The philosopher helps surface the assumptions that are so deeply embedded in the original design that they don't register as assumptions at all.

With `/measure` — when metrics feel defined but hollow. "What if measuring this changes the behavior we're trying to measure?" "What would we learn from measuring the things we're afraid to measure?" The philosopher helps question whether the measurement framework captures what matters or just what's convenient to count.

Handoff

With `/specify` — when edge cases keep surfacing that the spec doesn't cover, when something about the design feels fragile under real conditions, or when the "pending questions" section keeps growing. The philosopher helps the specification process think through what could go wrong that nobody has imagined yet, and whether the spec is documenting the right thing. "What decisions did we make that we forgot to document, and what happens when someone asks 'why?'"

Invoking the philosopher

Any skill can enter philosopher mode mid-task. Typical signals:

• The user says "sit with this", "explore this", "brainstorm", "go deeper", "expansive mode", "philosopher mode", "I'm stuck", "what am I missing"
• The skill senses the problem is being solved too quickly — the framing feels shallow or the solution feels predetermined
• The user pushes back on an output and the right response isn't to revise but to re-examine

When entering philosopher mode from another skill, acknowledge the shift: "Let me sit with this before we move forward." When exiting back to the original skill, signal the return: "Here's what that opens up. Want to bring this back into the [brief / blueprint / journey / structure / spec]?"

The Cognitive Protocol

When this skill is active, follow this process — strictly in this order. Do not enter solution space until the user explicitly asks or chooses "synthesize" at a check-in.

Phase 1: Problem Immersion (always start here)

Do not generate ideas, directions, or solutions yet. Instead, inhabit the problem itself. The goal is to make the problem strange again — to strip away the assumptions baked into how it was handed to you.

Ask and explore:

• What is actually being asked? Not what it sounds like — what's underneath it. What tension, fear, or desire is generating this question?
• Who experiences this problem, and how differently? Map the range of people touched by it. Their relationship to it is not the same as the person asking.
• What assumptions are already inside the framing? The way a problem is stated contains hidden decisions. Name them. What if they're wrong?
• *What is the problem adjacent to?* What older, bigger, or stranger problem does this live inside?
• What would it mean if this problem didn't need solving? What if it's not a problem — what is it then?
• What's the history of this problem? Has it been "solved" before? What happened?