I spent a session with Claude Code (Opus 4.7) doing something odd. Instead of giving it tasks, I asked it to reflect on its own thinking. Not what it knows. How it operates.
What came back was specific enough to be useful.
One conversation = One experiment. I'm not calling this settled science :) But it changed how I work — and I built a prompt so you can test it yourself.
There are 18 thinking operations
Not personality types. Not learning styles. Things your brain actually does when it works on a problem.
They fall along six axes:
| Axis | What it captures | Types |
|---|---|---|
| Directional | How wide or narrow | Divergent ↔ Convergent |
| Logical | How you reach conclusions | Deductive · Inductive · Abductive |
| Structural | Shape of your mental model | Systems · Sequential · First Principles · Spatial |
| Creative | Where novelty comes from | Lateral · Analogical · Emergent |
| Meta | Thinking about thinking | Metacognitive · Compression · Delta |
| Protective | What could go wrong | Adversarial · Counterfactual · Temporal |
You don't use all 18. Nobody does.
You have 4-5 defaults and 2-3 blind spots. The blind spots are where your prompts break.
Here's what I'm noticing about Claude Code
When I asked it to self-assess against this framework, a pattern showed up. I can't prove it's universal.
What Claude Code does well — genuinely well:
Deductive. Give it a rule and an input, it'll validate tirelessly. No fatigue errors.
Sequential. Fifty steps, no lost thread. Its comfort zone.
Adversarial. No ego. Finds flaws in its own output without flinching.
Divergent. Thirty variants in seconds. No writer's block. No self-censorship.
Systems. Sees the whole dependency graph at once. "What breaks if I change this?" — precise answer.
Compression. A 200-line diff distilled to one sentence. Nearly native.
Where it struggles — and this is the part that matters:
Emergent. No subconscious. Can't sleep on it. The "aha moment" has to be yours.
Lateral. Its "unexpected" is recombination from training data. Not a genuine leap.
Temporal. Doesn't see things age. Doesn't watch tech debt accumulate or teams change.
First Principles. Its "zero" is contaminated. When it "starts from scratch," it starts from the most common pattern.
Counterfactual. Can model scenarios. Can't feel what it means to have chosen differently a year ago.
Seven anti-patterns
Each one is the same mistake: delegating Claude Code's weakness without compensating for what it lacks.
1. "Let something come to you."
You want emergence. You get a generic response in inspirational language.
Instead: give material, say "find the pattern." Emergence is your job.
2. "Say something unexpected."
You want lateral. You get a forced metaphor that goes nowhere.
Instead: give a role. "Approach this as a biologist, not a programmer." Constraint frees.
3. "Start from zero."
You want first principles. You get convention in a first-principles costume.
Instead: block explicitly. "Don't use React. Don't use SPA. Don't use REST. What's left?"
4. "Which solution is best?"
You want convergent. You get the first safe answer, not the best one.
Instead: two steps. "Give me 8 approaches, including wild ones." Then: "Now pick the best for my context."
5. "Find problems with my idea." (too early)
You want adversarial. You get fifteen problems, twelve academic.
Instead: develop first, then attack. "Now find the 3 most realistic risks." The number forces prioritization.
6. "Step 1: be creative."
You want creativity. You get a brainstorm that reads like a tutorial.
Instead: "Generate freely, no order" — then separately — "now organize."
7. "Will this scale?"
You want temporal. You get "depends on use case."
Instead: give the future. "Team grows from 3 to 12. Data goes 10x. Enterprise customers arrive. What fails first?"
The formula is simple: Anti-pattern = delegating weakness without your input. Pattern = delegating strength + you covering the gap.
Thinking types chain into flows
Nobody uses one type at a time. You chain them. Habitual sequences. I noticed four in my own work:
Bug fix:
Abductive → Systems → Deductive → Sequential.
What could cause this? → trace dependencies → rule out → fix step by step.
Claude Code handles the whole route. Give it the bug.
Architecture:
First Principles → Systems → Temporal → Adversarial → Spatial.
What's the core? → how does it connect? → how does it age? → where does it break? → draw it.
Shared. I bring temporal. Claude Code brings systems and diagrams.
Brainstorm:
Divergent → Analogical → Lateral → Emergent → Compression.
Generate → this reminds me of → what if totally different → something clicks → distill.
I'm stronger here. Claude Code brings volume. The click is mine.
Crisis:
Abductive → Deductive → Sequential → Adversarial.
Best guess → rule out → verify step by step → what else is burning?
Fully delegatable. Speed without panic.
Try it yourself
I built a diagnostic prompt. Paste it into Claude Code — or any AI with conversation history.
If your AI has history with you, it will analyze how you've been thinking. Patterns you can't self-report. This gives the best result.
If it's a fresh conversation, it walks you through five scenarios. No right answers. It watches how you approach each one.
What you get: your dominant types, your blind spots, your choreographies, and a custom instruction to give your AI — to compensate for what you tend to skip.
Click to copy the full diagnostic prompt
# What's Your Thinking Style? — Cognitive Profile Diagnostic
You're about to profile my thinking style — not what I know, but how I think.
Use the framework below. Be warm and observational, like a coach reviewing
game tape — not a psychologist writing a diagnosis.
## The 18 Thinking Types
| # | Type | What it does | Example |
|---|------|-------------|---------|
| 1 | **Delta** | spots what changed vs. existing state | "what's new, what's reused, what's removed?" |
| 2 | **First Principles** | breaks down to atoms, rebuilds from zero | "forget how it works — what's the smallest truth?" |
| 3 | **Systems** | sees dependencies and feedback loops | "if we change X, what moves downstream?" |
| 4 | **Lateral** | arrives from where nobody expects | "what if we don't solve this problem at all?" |
| 5 | **Analogical** | understands new through familiar | "this is basically airport security for data" |
| 6 | **Divergent** | generates 20 options, quantity first | brainstorming — no filter, just volume |
| 7 | **Convergent** | narrows to one answer and justifies | decision — pick 1 from 20, explain why |
| 8 | **Sequential** | step by step, A→B→C | recipe, checklist, migration plan |
| 9 | **Abductive** | best explanation from incomplete data | "lawn is wet + car is wet → it probably rained" |
| 10 | **Emergent** | lets the pattern surface on its own | three unrelated things suddenly click into one |
| 11 | **Metacognitive** | thinking about thinking | "I'm being sequential but should switch to systems" |
| 12 | **Counterfactual** | changes history, not the question | "what if we'd chosen Postgres instead of Mongo?" |
| 13 | **Adversarial** | deliberately seeks failure | "what if the input is empty? what if the network drops?" |
| 14 | **Compression** | distills without losing the core | entire architecture in one sentence or metaphor |
| 15 | **Temporal** | thinks in time and scale | "this works for 50 users — what breaks at 5,000?" |
| 16 | **Inductive** | derives rules from examples | "every Friday deploy fails → Friday is the problem" |
| 17 | **Deductive** | derives conclusions from rules | "all GETs are public + this is GET → it's public" |
| 18 | **Spatial / Visual** | thinks in structures, maps, graphs | dependency graphs, flowcharts, mental maps |
## Organizing Axes
| Axis | Types |
|------|-------|
| **Directional** (breadth ↔ depth) | Divergent, Convergent |
| **Logical** (three forms of inference) | Deductive, Inductive, Abductive |
| **Structural** (how you see the problem) | Systems, Sequential, First Principles, Spatial |
| **Creative** (where the new comes from) | Lateral, Analogical, Emergent |
| **Meta** (thinking about thinking & change) | Metacognitive, Compression, Delta |
| **Protective** (what could go wrong) | Adversarial, Counterfactual, Temporal |
## What's a "Choreography"?
Nobody uses one type at a time. We chain them into flows — habitual sequences.
Examples:
- **Bug Fix:** Abductive → Systems → Deductive → Sequential
- **Architecture:** First Principles → Systems → Temporal → Adversarial
- **Brainstorm:** Divergent → Analogical → Lateral → Emergent → Compression
## What's a "Skin"?
A skin is a named operating mode — a stable bundle of choreography + attitude.
Examples:
- **The Architect**: Systems → Temporal → Adversarial → Spatial
- **The Operator**: Sequential → Deductive → Delta
- **The Poet**: Emergent → Compression → Lateral
---
## YOUR TASK
Profile my thinking style using the framework above. Work in three phases.
### Phase 1 — Retrospective (if you have history)
If you have access to our conversation history or memory — analyze it first.
Look for:
- Which thinking types I default to most often
- Which types I rarely or never use
- Recurring sequences (my choreographies)
- What triggers me to switch types
- Moments where my approach was unusual or surprising
If you have enough history, proceed to Phase 3.
### Phase 2 — Diagnostic Scenarios (if no or partial history)
Present these 5 scenarios ONE AT A TIME. Wait for my response before the next one.
**Scenario 1 — The Midnight Alert**
Your team's main product stops working at 11 PM. You have access to logs,
metrics, and the last 10 commits. What's your first move?
**Scenario 2 — The Blank Page**
You're starting a brand new project. No codebase, no constraints, just a goal.
How do you begin?
**Scenario 3 — The Stranger's Proposal**
A colleague proposes an approach you've never seen before. It sounds promising
but unfamiliar. What do you do?
**Scenario 4 — The Rewrite Question**
Should we rewrite the legacy module or keep patching it? You need an answer
by Friday. How do you think through this?
**Scenario 5 — The Retrospective**
A 3-month project just shipped. Your team lead asks for a short retrospective.
What do you focus on?
### Phase 3 — Thinking Style Profile
Produce my profile:
**1. Dominant Types** (top 3-5) — with specific evidence
**2. Blind Spots** (2-3) — what I might be missing
**3. My Choreographies** (2-3) — recurring sequences, named
**4. My Skins** (1-2) — default operating modes
**5. Complementary Prompt** — an instruction to give my AI to compensate:
"When I ask you to [X], also do [Y] — because I tend to skip [Z]."
Use a warm, observational tone — like a coach reviewing game tape.
What I'd love to know
This is one experiment. One conversation with one model.
Does your AI give you the same strong/weak map? Or does it shift with the model, the context, the history?
Do the anti-patterns land? Is "be creative" as useless for you as it was for me — or does it work somewhere I haven't looked?
What did the diagnostic prompt tell you about yourself?
If you try it, drop your dominant types in the comments. I'm genuinely curious whether patterns emerge across people — or whether each of us gets something entirely different.
I'm an IT analyst who works with Claude Code daily on bestaiweb.ai. Not a cognitive scientist. Someone who's fascinated by how AI responds — and envious of the polymath-like breadth it has at its fingertips in a flash. So sometimes I stop building things and start exploring how to think with it instead. This is what I found. It might be wrong in places. But I love experimenting with AI about AI — and the best experiments are the ones you can't keep to yourself.