Guides
Find why something fails
Switch to Debug mode, and the agent traces the problem through your code, collects evidence with diagnostics and reports what it found before anything is fixed.
In Debug mode the agent investigates a problem the way a developer does. It follows the code from where the problem starts, adds diagnostics where they answer a question, makes the problem happen, and reads what they show. It changes how your code behaves only when you say so.
Start
Type /debug with what goes wrong, what you did and what you expected:
/debug The Add to cart button does nothing. I expect "In your cart:" to go up by one, but it stays at 0.Jinion switches to Debug and sends the problem. /debug alone switches without sending anything, and shift+tab or
/mode gets you there too. The rule under the prompt says Debug.
What the agent does
- Settles what you did, what you expected and what happened. It asks when one of these is missing.
- Follows the code from where the problem starts: for a button, the button, the handler on its click, and what that handler calls, down to the request and the code that answers it.
- Names the two to four places where it could break.
- Adds diagnostics that tell those places apart, in your project's language and for where that code runs: a line in
a click handler in the browser, another in a route on the server, a
FileHandlewrite in a Swift app. Around a request it adds one before, one after and one where it fails. Each carries ajinion-debugcomment. - Makes the problem happen: by itself with a script written for the problem, such as one that runs the command or clicks the button in a browser without a window, or through you when only you can, with numbered steps.
- Reads what the diagnostics wrote, and moves them closer to the failure until the evidence settles it.
You see each step in the conversation, such as Open the evidence log and Read the evidence, with the lines that
arrived.
The findings
The agent ends with four parts:
| Part | What it says |
|---|---|
| The path | The steps from what you do to where it breaks, with file and line |
| Evidence | What was observed, each with the line of the log or output that shows it |
| Cause | Confirmed when the evidence shows it, suspected when it only narrows it down |
| Open | What is still unknown, and what it couldn't run or observe |
It never says it reproduced a problem it only read about. When nothing could run, it says so first.
Then it says what the fix would be, and waits. Ask for the fix, and it makes the smallest change, runs the same path again with the diagnostics in place to show it now goes through, and takes every diagnostic and script out.
Reproduce it yourself
When the problem needs you, such as a click in your own browser or on your phone, the agent ends its turn with the steps. Do them, then tell it:
Clicked it once, still 0.The diagnostics already wrote what they saw, so there is nothing to copy over.
Where the evidence goes
Each conversation has an evidence log, opened the first time the agent adds diagnostics:
| Code that runs | Writes to |
|---|---|
| On your machine: a server, a script, a test, an app in the iOS simulator | A file in ~/.jinion/debug/<id>/ |
| Where it can't write that file: a page in a browser, a sandboxed app | An address on 127.0.0.1, only for this conversation |
| On a real phone or another machine | Its own console. The agent says it can't read that |
The address takes lines only while the conversation is open. A log nothing wrote to for a week is deleted.
Leave Debug mode
Switch to another mode with shift+tab or /mode. The agent is told Debug is off, and takes out diagnostics it left
in the code unless you want them kept. Debug is for one problem, so a new conversation starts in the mode you had
before it.