Code

Code is the development environment: a file tree, an editor with AI completion and language-server intelligence, terminals, git, dev servers, and a browser preview — with chat sitting beside all of it, working on the same folder you are.

Open it from the app rail or Open Code in Home. It takes the full screen.

Pin a chat

Right-click a chat in the sidebar and choose Pin to top to keep it in a Pinned section above every other chat and group, however long ago it was last used. The most recently pinned chat is listed first. A pinned chat that belongs to a group is listed under Pinned instead of in the group, and returns to the group when you choose Unpin.

Share a chat

Right-click a chat in the sidebar and choose Copy chat transcript to paste its conversation and tool activity into another chat. Export chat as HTML downloads a standalone transcript with rendered Markdown, code, embedded image attachments, and expandable tool calls and results. Open the HTML file in a browser to read, share, or print it. Exports include the saved conversation; hidden prompts and private reasoning are omitted.

Open a project

Code opens on a welcome screen with Open project, Create project, and your recent workspaces.

New projects default to your home folder's Projects directory. Change this in Settings → General → New projects → Default project folder, or use Change default folder beside the current location on the Choose workspace page. Browse… applies your folder choice immediately. Typed paths save when you leave the field or press Enter; Escape discards your edit. Clearing the field restores the original default. Existing projects are not moved. Change location in the creation form overrides the location for that project only.

The folder you pick becomes the workspace root, and that is the boundary for file, git and search tools. An agent asking for a path outside it gets refused. That is the point — see Tools and permissions.

The layout

• Left: chat sidebar — sessions, groups, board folders, search, and a footer rail of tools.
• Middle: chat, with the composer at the bottom and the inference metrics strip beneath it.
• Right: file tree, editor tabs, and preview.
• Bottom: the terminal panel when you open it.

The footer rail of the sidebar is where the less obvious surfaces live:

Button	Opens
Issues	The issue tracker embedded in the Code window
Inference metrics	Token counts, tok/s, totals
Agent activity	What sub-agents are doing right now
Terminal	The terminal panel (Ctrl+`)
Code map	A map of the repository: its layers and modules, the files in a folder, and who calls a function
Dev servers	The dev-server screen
Orchestrate boards	The board hub

Collapse the sidebar to a 48-pixel icon rail when you want the room.

The Issues ticket button in the files toolbar replaces the file tree with this workspace's issues. The list starts with open issues, newest first; choose All or Closed, or search by title or ID. Use Filter to narrow by type, status, priority, or project (including No project). Filters combine with search and Open/All/Closed; select a filter chip to remove it. Selections are kept separately for each workspace while the app is open. Browsing a worktree keeps the issue list on the Code workspace.

Type in New issue and select Create (or Ctrl/Cmd+Enter). The first line becomes the title and additional lines become the description. Expand creates the issue and expands it in the background, then clears and focuses the input so you can type the next issue. Drafts survive switching panes and reloading.

Select an issue to view its description inside the pane, then Back to return to the list. Right-click, Shift+F10, or the row's ⋯ button opens issue actions: View, Edit in Issues, Send to chat, properties, expansion, sub-issues, copying, and deletion. Edit in Issues opens that issue in the full Issues app; View all issues opens the full Issues app.

The editor

CodeMirror with syntax highlighting, plus two AI editing modes and real language-server support.

Keys	Action
Ctrl/Cmd+K	Quick Edit on the selection — describe a change, get a diff
Ctrl/Cmd+I	Toggle Intent mode
Ctrl/Cmd+Enter	Force an intent proposal for the current line
Tab	Accept an intent proposal, AI ghost text, or an open completion; otherwise indent
Ctrl/Cmd+→	Accept the next word of ghost text
Ctrl+Space	Trigger a completion
F12 or Ctrl/Cmd+click	Go to definition
Ctrl/Cmd+S	Save
Ctrl/Cmd+W	Close the tab
Ctrl/Cmd+Tab	Cycle tabs
Ctrl/Cmd+F	Find and replace
Escape	Dismiss a proposal or ghost text, or blur the editor so Tab navigates the app again

Quick Edit is a surgical change to a selection. Intent mode is different: you write what a line should do (English, pseudocode, or even broken code) and pause — a proposal appears below the line. Tab accepts it and the text becomes ordinary code; Esc dismisses it; Ctrl+Z undoes an accepted proposal like any other edit. Nothing is written to your file until you press Tab.

Intent auto-triggers on lines that read as plain English (and on comment lines holding plain English) in files Minnow recognises as source code. If the detection gets in your way, set a trigger prefix in Settings — then only lines starting with it are treated as intent. Ctrl/Cmd+Enter always forces a proposal, whatever the line looks like.

Intent shares the editor AI model with inline completion and Quick Edit by default, and can be pinned to its own provider and model. Configure it in Settings → Integrations → Editor, which also controls ghost-text behaviour, how much import and language-server context goes into completions, and caching.

Language-server diagnostics, hover and signature help work where a server is installed — TypeScript and JavaScript are bundled. See Integrations.

Files get the same colourful icons as VS Code, in the tree and on tabs.

Markdown files

Markdown files open as a rendered preview, and you can edit them right there. Click any paragraph, heading, list, table or code block and it turns into its Markdown source. Edit it, then click elsewhere (or press Ctrl/Cmd+Enter) to see it rendered again. Esc throws away the changes to that block, and Ctrl/Cmd+S saves the file. Only the block you touched changes; the rest of the file stays exactly as it was. Links stay clickable, and selecting text to copy it does not open a block. To work on the whole file as source, right-click and choose Open as code (Open as preview switches back). Unsaved edits carry over when you switch.

Godot projects

Open a folder containing project.godot and Minnow recognises it automatically. If Godot 4 is already on PATH, in a standard installation location, or in your Downloads or Desktop folder, no setup is required. Portable Windows builds may remain in their extracted folder.

If Godot is not installed, use Settings → Integrations → Language servers → Install Godot, or ask the assistant to install Godot. The installer downloads the latest stable official Godot 4 build, verifies its published SHA-512 checksum, and keeps it under ~/.minnow/runtimes/godot/. The godot_control tool uses Ask permission by default, so an agent-initiated download still requires your approval. MINNOW_GODOT_PATH remains available as an advanced override.

GDScript files use Godot's language server for completion, diagnostics, hover, navigation, symbols, and formatting. The assistant can also open the editor, run or stop scenes, validate scripts, import assets, run a GDScript test runner, export builds, and use Godot's debugger.

The file tree

Full file operations, keyboard-driven when the tree has focus:

Keys	Action
Enter / Space	Open a file, or expand a folder
F2	Rename
Ctrl/Cmd+C / X / V	Copy, cut, paste within the workspace
Delete	Delete

Right-click for the context menu, including Open in System Explorer and Copy path (workspace-relative path on the system clipboard).

Drag a file or folder from Explorer or Finder into the tree to copy it into the project — onto a folder to import there, or onto empty space for the workspace root. Drag a file into the composer to attach it as a workspace reference the model can read with tools. Drag a file or folder into the terminal to insert its path at the shell prompt.

When an agent writes files, the tree patches only the affected folders instead of rebuilding. Your scroll position, keyboard focus and expanded folders survive.

Terminal

Ctrl+` toggles the panel. Tabs are the Agent tab, which shows the output of commands the model ran, plus any interactive PTY sessions you open.

• ↑ / ↓ recalls that tab's command history, kept per tab across reloads.
• Ctrl/Cmd+C copies the selection, or sends SIGINT when nothing is selected.
• Ctrl+V (Windows/Linux) and Cmd+V (macOS) paste clipboard text at the prompt.
• Expand fills the chat column with the terminal; press it again to dock.
• Sessions survive a reload — Minnow reconnects and replays scrollback rather than killing your shell.

On Windows, Git Bash appears when Git for Windows is installed, and installed WSL distributions appear as their own shell options. Pick one under Settings → Code & workspace → Terminal → Default shell (or override per workspace) and both terminal sessions and agent commands run inside it. WSL maps Windows paths to /mnt/.... Git Bash keeps a Windows working directory and does not use the WSL Landlock sandbox.

Git

The source-control panel does status, stage, diff, commit, branch, pull and push. If the folder is not a git repository yet, Set up git starts a background chat that initializes it (init, .gitignore, first commit) without leaving the panel.

Commit, push, pull, merge, and other git or GitHub actions show a small bouncing progress bar while they run. Success is a short confirmation. Failures open a popover with a plain-language title, a short summary, the raw details, and Send to chat so an agent can fix the problem.

• Commit messages can be generated from the staged diff: conventional commits with optional gitmoji, an imperative subject, and a body explaining why. The /git-commit skill uses the same conventions. History shows gitmoji as emoji even when a commit stored a colon code such as :sparkles:.
• File diffs: click a staged or unstaged file in the source-control panel to open the full file in the code editor. Added lines are highlighted; removed lines appear inline with their old line numbers. Unstaged files stay editable, with highlights updating as you type. Staged files open as read-only snapshots of the index, compared with HEAD. Deleted files open as read-only reviews. Commit diffs use the separate side-by-side review, with Wrap in the review header.
• Merge to main appears when you are on a feature branch: it checks out the trunk in the main workspace, merges your branch, and switches you back — warning you first if the tree is dirty and surfacing merge failures in a popover with an option to send them to chat.
• Names you type when creating a branch or worktree (composer, Source Control, or the git panel) are turned into a git-safe slug: Test Worktree becomes test-worktree. Empty or illegal characters are stripped; the dialog shows the name that will be used. The same dialog lets you pick which existing branch to start from (local or remote-tracking). For a worktree you can Check out an existing branch instead of creating a new one.
• Agents use the same git operations through tools, so you and the model are never looking at different states.

Source Control Center

The sidebar panel covers the everyday loop. For the full surface — Changes, History, Branches, Stashes, Worktrees, Pull requests, Actions, and Releases — open the Source Control Center from the navigation rail or that panel. It opens as its own app, keeping your chat intact. Ctrl+1–8 jump between sections; Ctrl+K opens the command palette. GitHub operations use your local gh CLI authentication. Open pull requests can be reviewed in-app with Review PR; the review stays in Minnow and is not posted to GitHub.

Actions and releases

Actions → Workflows lists GitHub workflows or the selected worktree's local workflow files. On GitHub, choose a remote branch or tag and complete the workflow inputs. Only workflows with workflow_dispatch can be started manually. Dispatch acceptance means GitHub received the request; open Runs to follow execution, jobs, logs, reruns, and cancellation.

For Local workflow (act), install act and start Docker. Choose an event, compatible Ubuntu job, and runner image. Local runs use the selected worktree, including uncommitted edits. Dynamic, Windows, and macOS runners are not treated as Linux. Local execution does not guarantee the same result as GitHub. Use the Source Control branch/worktree controls to choose the checkout; stop its active local run before switching branches or removing it.

Commands discovers root package scripts and supports named commands in .minnow/actions.json. Saved commands can specify a relative directory, shell profile, environment values, and references to encrypted local secrets. The command file is versioned; secret values stay in Minnow's local profile. The Run saved command button executes the saved definition. Package scripts use the declared package manager or detected lockfile, with npm as fallback.

Runs → Local runs shows status and logs. Runs continue when you close Source Control or reload its view. Logs are capped at 4 MiB per run and completed records are retained for seven days. Server shutdown stops local runs; interrupted runs are not automatically restarted. Local action secrets are passed only when selected and known values are masked in captured output.

Releases lists GitHub drafts, prereleases, and published releases. Create a draft from an existing tag or an explicitly selected remote commit for a new tag. Drafts open ready to edit. Select Write draft to create user-facing release notes from commit subjects and bodies since the last published release, including prereleases. Override the previous tag when needed; an initial release uses the full target history. The writer uses your utility model, or your default model when no utility override is set. Review the Notes and preview, use Undo to restore your preceding edits, and select Save changes to save. Cancel keeps your notes intact. Generate with GitHub remains available. Edit published releases with Edit release, choose prerelease/latest settings, and publish drafts when ready. Upload assets using paths relative to the worktree; downloads use a selected relative directory. Replacing or deleting an asset requires confirmation. Deleting a release preserves its Git tag. Immutable releases and accounts without write access show read-only controls. Run release workflow opens a popover for the mapped GitHub workflow. In Actions → Workflows → GitHub, select a manually runnable workflow and choose Use for releases to map it to this button. The mapping is saved locally per GitHub host and repository and applies across its worktrees. From Releases, choose a remote branch or tag, complete the workflow inputs, and select Run on GitHub. Inputs reload when the ref changes. Dispatch acceptance means GitHub received the request; View runs opens Actions to follow execution. Use Change workflow to pick another workflow, or Remove release mapping in its workflow inspector to clear the mapping. Running a workflow and creating a release are separate operations.

Agents use the same services through action_inspect, action_run, action_cancel, action_command, release_inspect, release_manage, and release_asset. Inspection defaults to Full permission; mutations default to Ask. Plan mode allows inspection only for these tools.

In Branches and Worktrees, click a row to select it, Ctrl/Cmd-click to toggle individual rows, or Shift-click to select a range. Ctrl/Cmd+A selects all visible rows; Escape clears the selection. Delete selected lists the targets for confirmation. Bulk deletion keeps unmerged local branches and dirty worktrees, with individual errors shown. Bulk deletion skips current and protected local branches and the main/workspace worktree. While deleting, progress shows the current item and its position in the batch.

In Pull requests, filter by Open, Merged, Closed, or All, and search the loaded list by title, number, branch, author, or label. The current branch's PR opens automatically when present. Overview shows the rendered description, check and review summaries, merge status, and reviews; Checks, Files, and Commits have their own tabs. Check Details links open the CI result on GitHub. Choose a merge method beside Merge; drafts must be marked Ready for review before merging. More → Close pull request closes without merging. Refreshes preserve the selected tab and an unfinished new-PR form.

Enable Remote in Branches to show remote branches. Use a row's delete action or include remote branches in a selection to delete them on their remote server. Local branches are kept. Remote main, master, and symbolic HEAD references are protected. Removing a worktree keeps its branch.

Code map

Code map in the sidebar draws the repository from its code index. Pick a view at the top left:

• Architecture — each top-level folder is a layer and each folder inside it is a card. Lines show calls between them, thicker for more calls; a layer that calls another sits above it, and a dashed line marks a call running back up. Third-party packages sit in their own layer at the bottom. Test folders are hidden until you choose Show tests.
• Files — the files in one folder, callers on the left and the files they call on the right. Each subfolder is one card; files with no calls inside the folder are listed underneath.
• Call graph — one function with its callers on the left and what it calls on the right. Depth adds a second ring.

Click a card to see what it is, what it depends on, and what uses it; double-click to go one level deeper. Cards most of the map relies on show used by N instead of drawing every line to them, and small modules fold into one N more modules card. Strong links shows the heavier connections; switch to All links or Cross-layer only from the same menu. Selecting a card always shows all of its lines.

Ctrl+K searches files, folders, and symbols. Type a question instead and choose Ask to open a fresh chat beside the map and send it immediately; the same works from the Ask about… box in the panel. A context card shows the selected code and your question. The agent receives its indexed details, including location, summary, and relationships. Continue using the reply field and Send/Stop. Closing the chat keeps the map open, and leaving the map shows the new conversation in the main chat view. Right-click a folder card to change its icon. The ⋯ menu copies the current view as a Mermaid diagram, saves it as a PNG, or resets the index; Reindex refreshes it.

Drag the divider beside the chat to make it wider or narrower. Minnow remembers the width. You can also focus the divider and use the arrow keys; double-click it to reset the width. On narrow screens, the chat sits below the map.

Dev servers

A first-class screen rather than a terminal tab you have to remember. Register the servers a project needs — command, working directory, port, auto-start, and which git worktree to run in — then start, stop and restart them from one place, with logs and a listening-ports view.

Choose Add server to open a popover. Enter the command you normally run in a terminal, give the server a name, and set its port. Advanced contains the working folder, worktree, network access, optional health check URL, and automatic startup. New servers default to the workspace root and this computer only. If the port is busy, choose Use a free port. Adding a server saves its configuration; choose Start when you are ready to run it. Detect in chat asks the assistant to find and configure the project's servers.

Minnow wires the Port field by stack: Vite gets --port, Next gets -p, and stacks that reject those flags (including electron-vite) get PORT / VITE_PORT in the environment instead. Configs that ignore env keep their own port. Split stacks (API + client via concurrently) inject the port into the client, set PORT for the API, and health-check the UI.

The manage_dev_servers tool gives the model the same controls, so "start the dev server and check the console" is one instruction.

Browser preview

A real Chromium view for workspace HTML and localhost URLs. Navigate, reload, and toggle DevTools with F12 or Ctrl/Cmd+Shift+I — console, network and element inspection for the previewed page.

The toolbar keeps navigation, the address field, expand, and close visible. Open the Browser menu (three dots) for History, Auto-reload, Design Mode, annotations, DevTools, and Split right. The menu shows each toggle's current state and includes zoom, hard reload, URL and screenshot copying, and in-app browser data controls in the desktop app. The split preview has its own menu for that pane.

The preview is the user surface for browser_* tools when an agent deliberately passes surface: "user" and an explicit tab_id. It is useful when you want the agent to work in a visible preview tab. Navigation is restricted to an allowlist that starts at localhost only; see Integrations.

For isolated work, the agent can use Agent Browser. It reserves a private headless tab, then passes the returned tab_id to every later browser call. Open the Agent Browser viewer from the browser sidebar button to watch a tab, select Guide to send a page-element note to its owner, or choose Take control for deliberate user input. Closing the viewer leaves browser work running, and screenshots still work while it is closed.

Working with the assistant here

The normal shape of a Code session:

1. Open the project. Set the composer to Build.
2. Ask for the change. The model reads files, proposes edits, runs tests.
3. Approve tools as they come up, or move the ones you trust to Full.
4. Check the diff in the git panel before committing.

Two habits that pay off: commit before a long agent run, and use Plan mode first when the change is big enough that you want to agree on the approach before any file is touched.

If a turn goes wrong, the undo control beside the changes strip rewinds the turn and restores the working tree from a git snapshot. See Working in chat.

Related

• Modes
• Orchestrate boards — parallel delivery from a plan
• Keyboard shortcuts
• Troubleshooting