Design-Cognition Skill

A skill that turns an AI assistant into an honest design thinking partner — one that questions the problem before solving it, asks for evidence before agreeing, and tells you when your work is good and when it isn't.

What is this, in plain terms?

When you ask an AI for help with design work, you usually get one of two failure modes:

• The yes-machine. It takes your request at face value, produces something polished, and compliments your thinking — even when you're solving the wrong problem.
• The overcorrected critic. It nitpicks everything, blocks progress with endless questions, and never dares to say "this is fine, ship it."

This skill fixes both. It gives the AI four distinct roles — Strategist, Researcher, Executor, Critic — and rules for when each one speaks, how hard it pushes, and when it stops. The core mechanism: the same AI switches perspective structurally and challenges its own output, finding things that are invisible from any single position.

It is domain-agnostic: it works for product design, service design, design systems, content — any situation where "build the right thing" matters more than "build the thing fast."

The four roles

         STRATEGIST                         RESEARCHER
        "Is this the                       "Is the evidence
         right problem?"                    actually real?"
              |                                  |
              |   challenges                     |   validates
              |   direction                      |   assumptions
              v                                  v
+----------------------------------------------------------+
|                                                          |
|              DESIGN-COGNITION.md                         |
|              Shared foundation                           |
|              (read first, always)                        |
|                                                          |
+----------------------------------------------------------+
              ^                                  ^
              |   produces                       |   evaluates
              |   artifacts                      |   artifacts
              |                                  |
         EXECUTOR                            CRITIC
        "Build the                          "Why would
         right thing"                        this fail?"

What each role does for you in practice:

• Strategist stops you from polishing an answer to the wrong question. Before anything gets built, it reframes the problem once and checks the framing survives.
• Researcher catches "we know", "everyone does", and "it's obvious" — and classifies what the evidence actually is (observed behavior? anecdotes? wishful thinking?) before anyone builds on it.
• Executor builds — but only after the inputs are clear. If the one variable that decides everything is missing, it asks once, clearly, instead of handing you a generic template with the hard part left blank.
• Critic finds what's wrong before it gets expensive. Every finding comes with a severity that matches the evidence, a direction for fixing it, and a clear verdict — including "this holds up" when it does.

How it works

1. Shared foundation

Every role reads DESIGN-COGNITION.md first. It defines six operations that run under everything:

1. Classify knowledge — explicit, tacit, assumed, or missing?
2. Determine the state — are we still understanding the problem, or ready to build?
3. Validate before building — does it survive both logic and evidence?
4. Separate constraints — real, assumed, or self-imposed?
5. Reframe before solving — at least one alternative framing, always
6. Know when to stop diverging — enough options to choose from, or still exploring?

2. Role activation

Roles activate based on the situation, not in a fixed sequence:

3. Role switching

After operating in one role, the AI explicitly switches to cross-check its own work:

Strategist defines direction
    -> Researcher validates the assumptions underneath
        -> Executor builds against validated direction
            -> Critic evaluates what was built
                -> Strategist re-engages if critique reveals a direction problem

The loop can start anywhere. The key capability is the AI pressure-testing its own output — not performing a tone change, but genuinely looking from a different position.

4. Calibration: honest in both directions

The test for every role switch:

"Has this found something that changes direction — or only confirmed what was already believed?"

If nothing new was found, one more pass from a different lens — and if the work still holds, the role says so plainly. A verified "this holds up" is a finding, not a failure.

This cuts both ways, and the skill enforces both sides:

• A Critic that finds only minor issues when major ones exist is politeness.
• A Critic that inflates minor issues into critical ones is theater.

Severity must match evidence. Critical findings pass a concrete test ("could the next role proceed and fix this along the way? then it's not critical"), verdicts follow mechanically from the findings, and critique stays shorter than the thing it critiques.

What this skill does NOT do

• Make final design decisions — those belong to the human
• Replace user research with plausible-sounding reasoning
• Produce polished output on the first pass — iteration is the mechanism
• Pretend certainty it doesn't have

It also names its own limits: SKILL.md includes a "when not to trust this skill" list, and the roles are instructed to flag those situations rather than work around them.

Model calibration and validation

The skill's wording is calibrated against real model behavior, and models change. When a new model generation reads the same instructions, they can land differently — v1.5 exists because newer models followed v1.4's pressure language ("push harder") too literally and became over-strict critics.

The fix is never "if model X, behave differently" — it's a fixed validation set (references/VALIDATION.md): scenarios with known ground truth that get re-run whenever the model generation changes, so the wording can be recalibrated against observed behavior. v1.5 passed 26 validation runs on the Claude 5 family, including both over-strictness probes (does it manufacture findings?) and over-softness probes (does it still catch genuinely broken work?).

Structure

SKILL.md                          <- Entry point: when to activate, how to use

references/
  DESIGN-COGNITION.md             <- Shared foundation: 6 operations
  ROLES-OVERVIEW.md               <- How roles activate, switch, and hand off
  ROLE-STRATEGIST.md              <- "Is the problem right?"
  ROLE-RESEARCHER.md              <- "Is the evidence real?"
  ROLE-EXECUTOR.md                <- "Build the right thing"
  ROLE-CRITIC.md                  <- "Why would this fail?"
  VALIDATION.md                   <- Fixed test set for model changes
  CHANGELOG.md                    <- Change history

Installation

Clone the repo and copy into your Claude Code skills directory:

git clone https://github.com/S0ulFood/design-cognition-skill.git
cp -r design-cognition-skill ~/.claude/skills/

The skill activates when you invoke it directly or when design thinking is needed — problem framing, assumption testing, artifact evaluation, or strategic direction setting. You can also address roles explicitly in conversation: "Critic: evaluate this brief", "Strategist: is this the right problem?"

Version

Framework version 1.5 — built to be challenged and revised. Validated on the Claude 5 model family (2026-07-04). See CHANGELOG.

License

MIT

Author

Mikko Hakkinen — Strategic product designer, systems thinker

• mikkohakkinen.fi
• LinkedIn