Jig · Documentation

Everything it does, and how to set it up

Jig is a browser built for QA: the page under test opens inside the window, and the panels around it read the form, fill it, break the server on demand, record what you did and write up what failed. This page is the whole of it, in order.

Install it Back to the product

What Jig is

A browser built for QA: the page you are testing opens inside the window, and the panels around it do the work you would otherwise do in five applications.

Jig is a desktop browser. You open the application under test in it exactly as you would in Chrome — your logins, your SSO, your cookies — and everything a tester reaches for lives in the same window: the form map, the fill, the network log with real response bodies, the accessibility audit, the recorder, the findings.

There is nothing to connect. No port, no token, no extension to install into another browser, and no “not connected” state to debug. Open it and it works.

By hand where judgement is needed, by button where it is not. Record a flow once and a button replays it; hand a whole task to Claude and it plans it, carries it out and files what broke. Neither is required — everything Jig measures runs locally with no model involved.

What it is not

It is not an editor with a preview pane, and it is not a test-automation framework. It does not ask you to write scripts, and it does not run in CI. It is the window a tester works in for the day.

Installing Jig

macOS: download the disk image, drag Jig into Applications, open it. The build is signed with a Developer ID and notarised by Apple, so it opens with a double-click — no right-click-Open dance, no Gatekeeper warning.

Windows: in progress. The signing certificate is bought and the build is being prepared; leave your address on the landing page and you will get one note when it opens.

Jig is a browser, so it downloads a browser engine with it — the package is large by design. Nothing else is fetched at first run unless you ask for it (see Claude and Dictation).

Projects, tabs and sessions

A project is a whole context; a tab is a session inside it.

Every application you test gets a project: its own folder and documentation, its own Jira, its own allowed addresses, its own saved logins, its own conversations — and its own colour, so five open at once are told apart before a word is read. The colour belongs to the project, not to the machine: open the project elsewhere and it looks the same.

Inside a project you get up to ten tabs, and each keeps its own cookie jar. That is what lets an administrator and a customer be signed in at the same time, side by side, without incognito windows or a second browser. Name a tab for what it is — double-click it, or press F2.

Starting over

“Forget this session” empties that tab’s cookies and storage and reloads: the page as a first-time visitor meets it. Other tabs and saved logins are untouched.

Reading and filling forms

Open the Form map panel and press “Read the form”. Jig walks the whole form in one pass and lists every field: what kind it is, whether it is required, which widget library it came from, and how that widget has to be driven. No clicking, and no guessing from the DOM.

Four sets of values

Valid — plausible values a form should accept. The fast way past a form you are not testing.
Limits — exactly the boundaries the fields declare: the longest allowed, the highest allowed.
Invalid — shapes the validation should refuse. The point is the error message.
Empty — everything blank, to see which fields the form actually admits are required.

Jig tells you what it did not touch, field by field: a list is left for you to choose, a consent tick is left alone because it may be a subscription, and a field whose own pattern refuses every value is named as such. A tool that silently ticks a consent box is filing a bug in your name.

When a control refuses

The reason is printed rather than swallowed: the value is not in the list (and here is what is), the field did not keep what was typed, something is lying on top of it, it sits inside a disabled fieldset, it is inside an aria-hidden region. A refusal that names itself is already a bug report.

Checking the page against the design

The Design panel compares what the browser renders with what the design says. Paste a Figma link — you get a table: element, property, the design value, the page value, and the token the page value came from. “The button is painted --accent-press instead of --accent” is a one-line fix; “the colour is 2% darker” is an argument.

Press Overlay for the other half: the two pictures on top of each other with a slider between them. That is the thing a table can never show — a block that has moved. You can also drop an image of the design into the panel instead of a link, for the projects where nobody has Figma access and the mock-up arrived in a chat.

Connect Figma once in Settings → Connections: a personal access token (Figma → Settings → Security → Personal access tokens, scope “File content: read”). Jig uses the REST API rather than the Dev Mode plugin on purpose — the plugin only works while the Figma app is running, and this has to work when it is not.

Two things worth knowing before you read the results. Sizes are only compared when the window width equals the frame width — a design drawn at 1440 read in a 1600 window differs in everything, so set the width in the toolbar first; the panel says which case it is. And the overlay compares blocks, not pixels: Figma and the browser antialias text differently, so a raw pixel diff would light up every letter of a perfectly correct heading.

The design check is part of Pro. It works through the trial month and then asks for a key. Reading the page’s own styles stays free.

Network, rules and findings

The Network panel lists requests with their real response bodies — not “500”, the sentence the server actually wrote. Copy any of them as curl, or send the same request again without touching the page.

Making the server misbehave

In the “By hand” panel, put part of an address in the field — say /api/orders — and press one of: fails with 500, answers empty, answers in five seconds, connection dies. The rule belongs to that tab and dies with it. No back end to talk into, no branch to deploy.

A finding is a ticket

Keep anything as a finding and it arrives with the steps, the environment, the request and the response already written out. Connect Jira and it files as a ticket; point the project at its repository and every finding carries the branch and commit under test.

Tokens are shown in full in the network panel — that is what makes it useful — and are redacted when a finding is copied or filed.

Recording a flow

Press Record, click the flow through by hand, press Stop. What is written down is the name of what you touched and the value it ended up with — never coordinates, so a redesign does not silently break the recording. A password is recorded as “a password was typed”, never as the letters.

The recorder will not save until you say what should be visible at the end. Only you know what “it worked” looked like; without it a replay would report a confident pass having proved nothing.

Runs, and the difference between two

Every run is kept. Compare the last two and you get the three answers a regression is about: what broke since last time, what got fixed, and what is still failing.

Handing over a task

Optional, and off until you connect it.

Type what to check and Jig plans it and carries it out, filing findings as it goes. Point the project at its repository and it reads the documentation and the Jira with it; give it a checklist and it works through yours rather than improvising.

Two ways to power it

Your own Claude subscription — connect it once from Settings and nothing is billed by us, with no cap from our side.
Our cloud — 200 calls a month are included with Pro. Enough for real work; the heavy agent is where your own subscription pays off.

The model is asked for a plan, once, and Jig executes it. The plan is cached against the form’s fingerprint, so a second run needs no model at all — which is why a hundred-field form takes seconds rather than minutes.

A claim is not a measurement

The checklist prints how many items were ticked on the agent’s word alone, separately from the ones the executor observed. A lead signing off a release is signing under the word “verified”, and the difference has to be visible.

Connecting MCP servers

The tools the chat can reach beyond the page under test — your tracker, your designs, your database.

Jig reads the .mcp.json in the project’s folder — the same file Claude Code uses, so a project already set up for your editor needs nothing new. Point the project at its repository in the Files panel and the servers appear in the MCP sheet.

Turning one on

Open the MCP sheet from the composer, or type /mcp in the chat.
Each row shows where the server came from: this folder only (the repository’s file, which travels with the team) or every project on this machine (your own).
Tick the ones this project may use. The choice is per project — the same server can be on here and off in the next one.
A change takes effect on the next question, not mid-answer.

Every server is off by default, and that is deliberate: each one is a door out of the application under test. Nothing is switched on because a file happened to be in a folder — you decide, per project.

What the rows tell you

Connected — answered the handshake and its tools are attached to the chat.
Needs auth — reachable, but it wants a token this machine does not have.
No answer — declared, not responding. Fix it outside and press Reconnect; there is no need to restart Jig.
This machine has no value for… — the file references an environment variable that is not set here. Jig names the variable rather than failing silently.

Credentials are never copied into the project record. Importing a repository reads its Jira, its documentation, its addresses and its server declarations — and leaves the secrets where they are, saying so in the import result.

Jig’s own tools are not MCP

The page verbs — read the form, fill it, click, press, force a network rule — are built in and always available to the chat. MCP is for everything that is not this page: the tracker you file to, the spec you check against, the database you look a record up in. The section below is the same door in the opposite direction: your editor reaching in here.

Driving Jig from your editor

The agent that writes the code has never seen the application run. Connect your editor and it can open the page, sign in as a role, fill the form and read what the server actually answered.

Everything Jig’s own chat can do — read the page, fill a form in one pass, click, press, upload, open a role, force a network rule, run the accessibility audit, read the network and the console — is available to any editor with an MCP client. Cursor, VS Code, Claude Code, whatever you already use. It does not replace your editor and it does not want to: you keep writing code where you write it, and the running application lives here.

Switching it on

1In Jig: Settings → Your editor (Cursor, VS Code), tick the box. It is off in a fresh install, because it keeps a local door open for as long as Jig is running.
2Copy the three lines Jig shows you and paste them into your editor’s MCP settings.
3That is all. There is no token to paste and no port to remember.

{ "mcpServers": { "jig": { "command": "npx", "args": ["-y", "jig-mcp"] } } }

While the door is open, Jig writes its address and a key to ~/.jig/connection.json (readable only by you) and the client reads it there. That is why nothing secret goes into your editor’s configuration file, and why a Jig that restarts on a different port needs nothing re-pasted.

Which project the editor lands in

The folder your editor is open in decides it. A project in Jig knows its folders, so a client standing in that repository is placed in that project by itself — nothing to configure, and no paragraph in a prompt that goes stale next week.

Several editors can be connected at once, and each keeps its own project. Neither moves the other.
Neither moves the window under your hands either: an editor switching project moves only its own pointer, and the strip in front of you stays where you left it.
A folder that belongs to no project is refused, with the list of projects — never aimed at whatever tab you happened to leave open. Say which one to work in (project_switch) and the client stays there.

What it may do

Exactly what the chat in this window may do, and it is refused for exactly the same reasons. Reading — the page, the form map, the network, the console, the audit — is always available. Acting in the application passes the project’s consent switch, its allow-listed addresses, tab isolation, the destructive-name check and the action budget. See Permission to act below: connecting an editor grants nothing that was not already granted.

Jig has to be running. With the window closed every call answers jig-not-running and says so in words rather than timing out — and switching the box off shuts the door and takes the address file away with it.

When it does not answer

jig-not-running — the window is closed, or the box in Settings is unticked. Both look the same from outside, and both are fixed in the same place.
no-project — the folder matches no project. The answer lists the projects; name one.
refused with a reason — the project’s own answer (consent, address, isolation, a destructive name, the budget). It is not a fault to retry around; it is the setting you have not made.

Permission to act

Off in a fresh install, and it stays off until you say otherwise.

Read-only, Jig looks and measures: it never types, clicks or submits on your page. Turn acting on for a project and it may type and press — and only on the addresses ticked in that project’s settings.

Two rails that do not move

Jig never acts in a tab you are signed into yourself — acting happens in tabs with their own session.
It never presses a control that deletes, pays or publishes unless you used that word in the task yourself.

A run also has an action budget: how many times it may touch the application before it stops and says so. Both live in the project’s settings, next to the address list.

Accessibility checks

Run the audit and get the machine-detectable WCAG 2.2 violations with the element, the impact and the wording to quote in a ticket. Walk the Tab order and see where focus jumps, where it falls into something hidden, where it never comes back.

An automatic check finds roughly a third of WCAG failures. Everything about meaning — whether an alt text says the right thing, whether an error explains what to do — needs a person. A clean run means “no machine-detectable violation”, never “accessible”.

A widget Jig cannot drive from the keyboard is reported as a finding rather than swallowed: if a keyboard user cannot operate it, that is a defect in the page, and in the EU it has been a requirement since 2025.

What leaves the machine

The browser, the inspector, the form map, the fill, the network rules, the recorder, the audit and the network log are local. Nothing about them is sent anywhere.

Hand a task to Claude and the field names of the page travel with the question. What you type stays here.
A screenshot only ever leaves if you switch that on yourself (Settings → “Send a screenshot with a free question”).
Saved logins are encrypted by the system keychain. If the system refuses to encrypt, nothing is stored — better forgotten than kept in the clear.

Licence and key

Everything that measures is free forever: the browser, projects, tabs with their own sessions, the inspector, the form map, the accessibility audit, the network log with response bodies, findings and Markdown export.

Pro adds everything that repeats: roles, fill by set, network rules, record and replay, runs and their comparison, Claude, Jira and MCP servers. The trial is a full month — two weeks is not long enough to meet a regression, and the regression is what Pro is for.

A Jig Pro key also unlocks Qiksy QA Copilot Pro, our Chrome extension. It works this way round only: a QA Copilot key does not unlock Jig.

Entering the key

Settings → Licence key, pasted from the purchase letter. One payment for the year; nothing renews itself, because our till does not keep your card.

Keyboard

The shortcut list lives in the app itself, behind the “?” in the toolbar — it is built from the same array the shortcuts are bound to, so it cannot drift from them. The ones worth knowing on day one:

F6 — move between areas: tools, address bar, tabs, the page under test.
F2 — rename the tab (or the project) you are on.
Alt + 1…9 — jump straight to a panel.
⌘1…⌘9 — go to that tab; ⌘9 is the last one.

Everything in Jig is reachable from the keyboard, including the panel grips — a tool that reports other people’s keyboard traps has no business having its own.