---
id: xray
title: Look inside the machine
area: Going deeper
order: 92
summary: One word — /xray — turns any answer Dex gave you into a lesson on how it works, using your own conversation as the material.
---

Most software asks you to trust it. Dex would rather show you.

Type `/xray` after any answer and Dex stops working and starts explaining: what it read, which of your files it opened, what it was told to do before you typed a word, and why it took the route it took. Not a generic help article — a walkthrough of *your* last conversation.

It's the most useful word in Dex, and the least used. Two reasons to make it a habit: it's how you learn whether an answer deserved your trust, and it's the fastest education in AI you'll get, because the example is always something you actually cared about.

## The journey of one question

Before the example, the shape of the thing. Every answer Dex gives you takes the same five steps — and `/xray` is simply Dex narrating the ones you didn't see.

```flow From your question to your answer
You press enter :: a plain question, typed the way you'd say it out loud
Context arrives :: your brief, your priorities, today's date — already loaded, before you typed
Dex goes and looks :: opens the files and connections that could answer you — this is the part that's invisible
Judgment happens :: it weighs, ranks and decides — the step no file dictates, and the step worth checking
The answer, and a trail :: you get the reply; anything worth keeping is written back into your own files
```

Steps two and three are the ones people are surprised by. Step four is the one worth arguing with.

## What it looks like

You ask something ordinary. Then you ask how it happened.

```terminal Dex — /xray
> What should I focus on today?
~ Reading your plan and calendar
* Three things, in order:
* 1. The Meridian renewal note — you promised Sarah a view by Friday, and it's slipped twice
* 2. Board pack, section two — 90 minutes, and your only clear block is 9–11
* 3. Reply to Tom. Two weeks now, and it's getting awkward
 
> /xray
* Here's what happened under the hood.
 
# Before you typed anything
. Your standing brief loaded — who you are, how you like to be answered
. This week's priorities and today's plan came in automatically
. Today's date was stamped in, so "Friday" means the right Friday
 
# Then, to answer you
. Read your week's priorities
. Read today's calendar — 4 events, 2 of them movable
. Searched your notes for open promises, and found the one to Sarah in a meeting note from 14 days ago
. Checked your task list for anything overdue
 
# The part that was judgment, not lookup
* Nothing in your files says which of the three comes first. I put a promise made to a person above internal work, because your profile says that's how you'd want it.
* If that's wrong, say so and it stops happening.
```

That last section is the one worth reading twice. Dex separates **what it looked up** from **what it decided** — and those are different kinds of wrong. One you check; the other you argue with. Knowing which you're dealing with is most of the skill of working with AI.

```split The same answer, sorted into two piles
Looked up — open the file and check it | Worked out — Dex's judgment, argue with it
Your priorities for the week, and today's plan | That the promise to Sarah comes first
Today's calendar — four events, two of them movable | That a promise to a person outranks internal work
The promise to Sarah, in a meeting note from 14 days ago | That the board pack fits in the 9–11 block
Everything overdue on your task list | That two weeks of silence with Tom has become a problem
```

Notice the shape of it: the left column is checkable in seconds, and the right column is where a wrong answer would actually come from. That's where to spend your attention — and it's exactly the column most software never shows you.

## Five ways in

`/xray` on its own explains the conversation you just had. Add a word and it opens a different door.

| Type this | And you get |
|---|---|
| `/xray` | What just happened in this conversation, step by step |
| `/xray ai` | First principles — why AI forgets, what it can hold in mind at once, what that means for you |
| `/xray dex` | How Dex itself is assembled: the brief, the automatic behaviours, the tools, the skills |
| `/xray boot` | Everything that loads before you type a word, and where each piece comes from |
| `/xray extend` | The four levels of making Dex yours, explained against your own setup |

`/xray boot` is the quiet favourite. Most people are surprised how much has already happened by the time the cursor blinks.

```stack What's already loaded before you type
Your standing brief :: CLAUDE.md — who you are, how you work, how Dex should behave :: every session
Automatic context :: this week's priorities, today's plan, anything overnight :: every session
Connected tools :: your calendar, meetings, tasks, whatever you've plugged in :: on demand
Your skills :: the recipes behind /daily-plan, /meeting-prep and the rest :: when called
Your files :: the notes, people and projects underneath all of it :: the source of truth
```

## Ask it to draw you the picture

Here's the part people don't think to try. Dex can explain itself in words — but it can also **draw itself**, and the drawing lands in your own notes where you can keep it.

Ask for a diagram and you get one in the standard format that Obsidian and most note apps render as an actual picture. So "how does this thing work?" becomes a diagram you own, made from your setup rather than a generic marketing graphic.

```prompt Draw me the machine
Draw me a diagram of what actually happens between me pressing enter and
you answering — in my setup specifically, not in general. Show what's
already loaded before I type, what you go and fetch, where judgment
enters, and where the answer gets written back. Use a diagram I can save
into my vault, then walk me through it in plain language underneath.
```

The same trick works on anything you're trying to hold in your head:

- *"Draw how my meeting notes turn into tasks and person pages."*
- *"Draw the path a promise takes from something I said in a meeting to something I actually did."*
- *"Draw my week — where my time goes, by pillar."*

**Make it your own:** ask for the diagram once, save it in `06-Resources/`, then ask Dex to redraw it whenever you've changed your setup. A picture of your own system, kept current by the system itself.

## Using it to check the work

The honest reason to look inside isn't curiosity. AI is mostly right and occasionally confidently wrong, and the difference is invisible from the outside — a wrong answer is written in exactly the same tone as a right one. What isn't invisible is the trail.

```prompt The trust check
Take the answer you just gave me. Show your working: for every factual
claim, which file did it come from and can I open it? Then mark each
claim as one of — read it in my notes, worked it out, or assumed it.
Anything in that third pile, say so plainly and tell me how you'd
confirm it.
```

Three habits worth forming:

- **X-ray answers that surprised you.** Either you learn something about your own business, or you catch a wrong turn early.
- **X-ray before you act on something that matters.** Board numbers, a promise to a customer, anything with a person's name on it.
- **X-ray when Dex feels off.** Nine times out of ten the trail shows the problem instantly — a stale file, a connection that quietly stopped working, an old instruction still steering it.

> This is the design position, stated plainly: everything Dex knows is a plain file you can open, and everything it did is a trail you can follow. Doubt is a supported way of working, not an insult.

## Then teach it back

The last thing `/xray` is good for is checking that *you* understood — which is the difference between reading about how AI works and being able to use it.

```prompt Teach it back
Explain what you just did to me as if I'm smart but have never used AI —
no jargon, and stop and explain any word I'd have to look up. Then flip
it: ask me three questions to check I actually followed it, correct me
where I'm wrong, and finish with the one thing from this that's most
worth me knowing cold, given how I use you.
```

Once the machine stops being a black box, the next question changes. It goes from *"can it do this?"* to *"what would I have to change for it to do this?"* — and that question has a page of its own: [make Dex your own](make-it-your-own.html).

```handoff
I just read the Dex Guide's page on /xray. Do it live on our last
exchange: what loaded before I typed, which of my files you opened, what
you looked up versus what you judged, and which instruction of mine was
steering you. Keep it in plain words. Then draw me a diagram of that
whole path in my setup and save it into my vault. Finish by telling me
the one thing about how you work that would most change how I use you —
and what I should change to get it.
```