thinQit Cody

Your thinQit coding teammate in VS Code. Ask a question or describe a change, let Cody do the work on a thinQit machine, and review every file it touches right in your editor.

What it does

• A panel of its own. Open thinQit Cody from the activity bar. The Q turns into the green presence sphere when you sign in, breathes while Cody works and flashes once when a turn ends.
• Any repository. GitHub, Azure DevOps, GitLab, Bitbucket, a server of your own, or a folder with no remote at all. No token and no list of hosts: when the Cody machine cannot fetch your repository itself, your editor copies the commit you are on to it, once, and after that only what a new commit changed.
• Ask or change. Type what you need. Cody answers, asks one question back when your request could mean two things, or starts a turn on a thinQit machine. Questions about the repository run as read only turns; changes run as change turns.
• Short replies. While Cody works you see one live line. When it is done: the outcome in a few lines, the files, and the steps closed. One click opens the steps, one more a command with its output. Choose Short, Normal or Detailed.
• Everything at the bottom. A status line under the message box shows the mode, the reasoning level, how full Cody's working memory is and your credits. Each opens its own small panel, and the details are one click away.
• Edits land in your editor. Each file Cody writes appears in your workspace as it happens. Open files change through the editor, so undo works and unsaved work stays unsaved.
• Review per file. The diff list shows every file with its line counts. Open a diff, accept a file, or revert it. Revert keeps anything you typed after Cody's edit.
• Images show as images. A screenshot or another image Cody saves in your workspace (png, jpg, jpeg, gif, webp, svg) has a thumbnail in its file row, and shows under the message that names it. A click opens it in the editor's image preview.
• Commit and push from the panel. Once you accepted a turn's files, Commit and push commits exactly those files with your own git and pushes your branch. Nothing else in your working tree goes along.
• Typing during a turn is safe. When you change a file Cody is also changing, the two are merged. When the changes overlap, Cody writes nothing and asks you to choose: take Cody's version or keep yours.
• Stop at any time. Stop ends the turn within seconds. Edits made so far stay and can be reverted.
• Big or sensitive changes wait for one click. When Cody changes more files than usual, deletes or renames many files, or touches a file that may hold secrets, those edits wait on the Cody machine. A card in the turn lists the files with "Apply these changes" and "Skip"; it still works after the turn has ended.
• Project memory. Cody keeps notes on what it changed and decided, every turn. The Memory tab shows them with the state of the project index; you can search, filter by kind, edit or delete any note, and add your own. A note Cody wrote guides later turns only after you confirm it.
• Relevant files. A small index of your repository on your own machine suggests the files that matter for your message, so Cody looks there first.
• Connectors. Give Cody tools outside your repository, from MCP servers: a remote server with a token, a local server package, thinQit's own tools, or your own config files. Calls that create, send or delete wait for your Allow in the turn.
• Capabilities. thinQit adds skills to Cody: slash commands such as /review and /tests, cards with results such as the last test run, ready made connectors, and tools on the Cody machine. Standard ones are always on; optional ones you switch on in the settings.

Requirements

• A folder that is a git repository, with the git command available.
• At least one commit. Any host, or none.
• A thinQit account with thinQit Cody enabled and credits.
• VS Code 1.95 or later. Remote SSH, WSL, Dev Containers and Codespaces work: the extension runs next to your files.

Getting started

1. Open the thinQit Cody view in the activity bar and choose Sign in.
2. Allow thinQit Cody on the thinQit page in your browser. You come back to the editor signed in. If the browser cannot open the editor, copy the code from the page and choose Paste code.
3. The first time, Cody prepares your project on its machine. This happens once per repository. When the Cody machine cannot fetch your repository itself, your editor copies it; on a slow connection that takes a few minutes, and you can keep working.
4. Type a message and press Enter.

For a private GitHub repository, thinQit Cody: Set Git Token is an optional faster way: a fine grained token with read only access to Contents lets the Cody machine fetch it directly. It is stored encrypted at thinQit and never shown again.

Commands

In the message box: /ask asks about the repository without changing files, /do starts a change right away, /new starts a fresh session and /stop stops the running turn. Type / to see these and the commands of your capabilities.

Settings

Images

When a turn saves an image in your workspace, for example a screenshot, its file row shows a thumbnail and Open in place of Diff (an svg keeps Diff, because it is text). When Cody's message names the file, by its path or by its file name, the image shows under that paragraph, at most 4 per message. A click opens the file in the editor's own image preview.

Only image files of that turn that are in your workspace are shown. The panel never loads an image from an internet address, and an svg is shown as a picture, never as markup. An image you revert, or that Cody deletes again, leaves the chat. An image over 10 MB shows a chip to open it instead of a preview.

The status line

Under the message box:

• Mode: Ask (read only, a question) or Change.
• Settings: the reasoning level (Quick, Balanced, Deep, and Maximum where the engines have it), the engine, and the reply length. A level shows its typical credits and time only once thinQit has measured enough real turns at it.
• Workspace: in sync or not, the branch, the base commit, Sync now.
• Working memory: how full it is and what fills it (the conversation, files Cody read, the project memory, tool results), what your next message does, Summarise and continue and Start fresh.
• Credits: this turn, this session and your balance.

Arrow keys on a focused chip change its value. Your choices are remembered per project and travel with every message.

Commit and push

The Cody machine never commits or pushes: git stays on your machine. After a turn, when every file has your decision and at least one is accepted, the Files block shows Commit and push. It opens a small form:

• the commit message, filled in from the turn's summary (a first line of at most 72 characters); change it as you like,
• the files that will be committed: exactly this turn's accepted files, and nothing else that is changed or staged in your working tree,
• the branch you are on and where the push goes (the branch's upstream; a branch that is not on the remote yet is pushed with git push -u origin <branch>),
• the commands as they will run, which follow what you type,
• Commit and push and Commit only.

The extension runs your own git, one command after the other and without a shell: git add for those files, git commit for those files only, and git push to the branch's upstream. Your commit hooks and push hooks run as they do in a terminal. It never forces a push, never amends a commit and never skips a hook. It does not commit while a merge or rebase is in progress, on a detached HEAD, when git does not know your name and email, or while one of the files has unsaved changes in an editor, and it says so in the form.

The chat then shows the short id of the commit and where it was pushed, with Open the pipeline when the remote is on GitHub, Azure DevOps, GitLab or Bitbucket. When something stops the commit or the push (the remote has newer commits, a hook fails, your account may not push), the panel says what happened and what to do; git's own output is in thinQit Cody: Show Turn Log. After Commit only, or when the push did not go through, the Files block offers Push.

Turn it off with thinqitCody.ship.enabled.

Connectors

Connectors give Cody tools outside your repository, from servers that speak MCP (the Model Context Protocol). They belong to your thinQit workspace, so they work in every project and every editor you sign in with, unless you limit a connector to one project. Open the Connectors tab (or thinQit Cody: Open Connectors) to add, edit, switch off, test or delete them; thinQit's Settings has the same list.

Ask before changes. Every connector has this switch, on by default. A tool that creates, sends or deletes something then waits in the turn: a card shows the connector, the tool and its arguments (secrets removed), with Allow and Skip. Skip tells Cody you did not allow the call. Reading never asks. The turn waits up to 10 minutes for your answer. Under "Which tools ask" you can name tools that should always ask or never ask.

Test connects once and lists the server's tools, with what each one does in a turn: reads, asks first, or runs without asking. For a local server the test checks the allow list; its tools are listed when a turn starts it.

Secrets are write only. Header values, variable values and config files are sent to thinQit once when you save, stored encrypted, and never shown again: the list shows header and variable names and the last 4 characters of a value. Leave a value empty when you edit to keep it.

Honest limits.

• Connectors you added to an AI assistant's own website or desktop app belong to that sign in, so Cody cannot use them. Cody keeps its own connectors: add them here.
• Servers in your own config files act without asking: Cody cannot ask you before they change something. You are responsible for what they start.
• A .mcp.json file at the root of the repository is used as well. Its servers are not in the list and act without asking.

Capabilities

Capabilities are what thinQit adds to Cody, released with thinQit itself: no update of the extension is needed for a new one, unless it says it needs a newer version. The extension asks thinQit for the list when the project is ready and again every 10 minutes.

Standard and optional. Open the settings (the gear in the panel) to see the Capabilities section. Standard capabilities are always on. Optional ones have a switch and show their price per use, in credits; some cost nothing and are still counted. Your administrator can switch a capability on or off for the whole workspace; it then has no switch here. When a capability needs something you do not have yet (a connector, an engine, a newer extension), the section says what, and offers Add connector when a preset fits.

Commands with arguments. Pick a command from the / menu and a small form opens above the message box: a text, a file (type the path or choose it with Choose) or a choice from a list. What you type below the form is added to the command. You can also type the whole line, for example /tests lib/naming.ts only the edge cases: values fill the arguments in order, name=value sets one by name, and the rest is extra text. When a required argument is missing, the form opens. A command always starts a turn in its own mode (a question or a change); the line you typed shows in the chat.

Cards. The Cards tab appears when a capability that is on has cards. Each card has its own Refresh; while the tab is open, cards refresh on their own interval, and after each turn. An item can open a file of the repository or an https page.

Connector presets. A preset fills in the server and which tools ask first; you fill in its token or variable fields. Values are write only, like every connector secret: sent to thinQit once and never shown again. A token field may add Bearer in front of what you paste.

Tools that ask first. A capability tool that asks first waits in the turn like a connector call: a card shows the capability, the tool and its arguments (secrets removed), with Allow and Skip. The turn waits up to 10 minutes.

Memory notes Cody writes. Only notes you wrote and notes you confirmed guide later turns. Each note Cody wrote has Confirm; a confirmed note shows Confirmed and has Remove confirmation.

What is sent, and what is never sent

Before every turn the extension syncs your local changes to the Cody machine, so Cody works on exactly what you see:

• the commit your work is based on (the last commit you pushed, or where your branch left the remote default branch),
• every change since that commit: unpushed commits, staged and unstaged changes, new files that git does not ignore, and unsaved editor buffers,
• nothing when nothing changed since the last sync.

Files in .gitignore are never synced. A sync is limited to 20 MB and 2,000 changed files; new files over 1 MB are skipped. When your changes are larger, the panel asks you to commit and push first.

With each message the extension sends context: the path of the active file, the visible lines, your selection (at most 16 KB, never from a secrets file or a file your exclude setting covers), the paths of open files (at most 20), up to 50 problems, the last three terminal commands with their output (at most 8 KB), the branch name, and the paths of up to 8 relevant files with a score. File contents are not sent as context.

Relevant files. At the first message the extension builds a small word index of the files git tracks (no file over 256 KB, no binaries, lockfiles, minified bundles, node_modules, dist, build or .next, and never a secrets file or a file your exclude setting covers). It stays on your machine, in the editor's storage for the extension, and only the paths it ranks are sent. Turn it off with thinqitCody.context.relevantFiles.

Never sent. Files that usually hold secrets are withheld and never written by Cody without your click: .env files (except .env.example, .env.sample and .env.template), keys and certificates (*.pem, *.key, *.p12, *.pfx, *.jks, *.keystore, id_rsa*, id_ed25519*), credential files (.npmrc, .pypirc, .netrc, .git-credentials, .aws/, .ssh/, .docker/config.json, credentials.json, service-account*.json, secrets.json and similar data files), Terraform state and variables, and anything matching thinqitCody.sync.exclude. A changed file that contains something that looks like a key or token (cloud keys, Git tokens, model API keys, Slack and Stripe keys, private keys, long JWTs, thinQit tokens, or a password assignment) is withheld as well, and the panel tells you which file. In your selection, terminal output and problem messages such values are replaced with [redacted].

Limit of the filter. Secrets that are already committed to your repository are on the Cody machine through the clone. Remove them from the history if they must not be there.

How credits work

Each turn is charged in thinQit credits by the tokens the coding engine used. An optional capability adds its own price per use (per turn, per command or per tool call), shown next to its switch. When a turn starts, thinQit holds a small amount of credits; when it ends, you pay what the turn used and the rest of the hold comes back. A turn that failed on thinQit's side and changed nothing costs nothing. A turn you stop, or that reaches its credit limit, costs what it used. The panel shows the credits left, a running estimate during the turn and the credits charged at the end. Conversation replies that do not start a turn are not charged.

Engines

Cody can run a turn on two coding engines. Your account decides which ones you may use and which one is the default; the panel shows their names. When the engine you picked fails, stalls or hits a limit, the other one takes over once and the turn card says so.

Privacy

• The extension talks only to the thinQit address in thinqitCody.server. It sends no telemetry.
• Your sign in token is kept in the editor's secret storage and can be revoked in thinQit under Settings, Integrations, VS Code, or with Sign Out.
• Connector secrets you type in the panel go to thinQit when you save and are not kept by the extension.
• When your editor copies a repository to the Cody machine, what travels is what a clone would bring: the tracked files of the commit you are on, committed secrets included. Never an untracked or ignored file, never the objects of the history. The commit log travels as names, dates, messages and file names, without e-mail addresses and without diffs.
• Review state (the originals needed for Revert) stays on your machine in the extension's workspace storage and is removed when every file is accepted or reverted, or after 7 days.

Support

Questions and problems: thinqit.io/support. Please include the output of thinQit Cody: Show Turn Log; it holds no file contents and no tokens.