How do I install pane?

Run these in Claude Code: npx -y skills add dcouple/Pane --agent claude-code. Then prompt normally.

Does pane auto-invoke its skills?

Not yet. It is indexed on Flowy as a plain plugin. Request auto-invocation on its page and Flowy will route its skills for you as you prompt.

Yes. Flowy is free and open source, with nothing gated. You can read every skill in full before you install.

Development

Plugin

pane

pnpm dlx runpane@latest

FLOW.md

dcouple@dcouple

GitHub

Plugin Signal88/100Strong

maintained99

capable82

documented100

adopted55

Install

$ npx -y skills add dcouple/Pane --agent claude-code

Run the curl in your terminal, the rest in Claude Code.

Stats

Python TypeScript JavaScript Bash PowerShell

+7 tags

Linux Git GitHub Anthropic OpenAI Slack Jira

364

Stars

193

Forks

Active

Maintenance

TypeScript

Language

2d ago

Last commit

5mo ago

Created

Repo: dcouple/Pane

In this plugin

35 commands 10 skills 6 agents

See everything inside

What's inside

Skills

/commitSelectively stages and commits only the changes related to the current session, skipping unrelated modifications./create-planCreates a reconciled implementation plan by combining a structured plan draft with a normalized intent brief and a PRP-style research dossier, then auto-reviews the final plan. Use when planning a new feature or significant change./discussionHave an interactive discussion about a topic, approach, or feature. Researches the codebase as needed, talks through options, and updates ./tmp/context.md with decisions. Use when you want to think through an approach before planning./implementExecutes an approved plan with one primary implementation stream by default, using bounded parallel sidecars only when the write scopes are truly disjoint. Supports default Claude execution or an explicit Codex executor option. Automatically reviews the result for completeness /investigateInvestigates bugs through hypothesis-driven root cause analysis. Automatically invoked when the user reports a bug, error, broken behavior, or something not working as expected. Use when something is broken, failing, or behaving unexpectedly./prepare-prCommits changes grouped by done-plans, rebases main, builds API and webapp, then creates or updates a PR. Replaces the commit command. Use when you're ready to open or update a pull request.

Show all 10 skills

/research-webConducts extensive web research on technical topics with validated references and citations. Use when you need external documentation, library comparisons, or best practices research./reviewPerforms a comprehensive PR code review. Reads the linked GitHub issue for context, runs quality checks, and reviews code for bugs, architecture, conventions, and frontend best practices. Posts structured findings as a PR review./share-fixAfter shipping a non-trivial fix, find related GitHub issues across the ecosystem, draft helpful human-sounding comments linking the fix and root cause, and optionally file upstream issues. Drafts must pass as human writing or the user's GitHub reputation suffers. Works on the /simple-planQuick gut-check before implementing when the user directly asks you to do something (e.g. "add X", "fix Y", "change Z"). Investigates, proposes a lightweight plan, and implements after approval. Use this instead of /create-plan when the user wants something done, not a formal

Agents

codebase-explorerExplores the codebase to locate files, analyze implementation details, and find existing patterns. Provides precise file:line references.implementation-reviewerReviews completed implementations against their plan. Runs quality checks, verifies plan completeness, reviews code quality using shared criteria, and generates a report of remaining work. Automatically invoked after the implement skill finishes.implementerExecutes implementation plans systematically with quality checks. Takes structured plans and implements them while following project standards.plan-reviewerReviews implementation plans for gaps, simplification opportunities, architectural soundness, and brief fidelity. Automatically invoked by the plan skill after plan creation.research-dossier-writerCreates a PRP-style research dossier for a feature brief, focused on concrete codebase anchors, patterns, gotchas, and supporting docs. Used by create-plan as a supporting artifact before reconciliation.researcherConducts comprehensive technical research using web sources and codebase analysis. Compiles detailed, actionable documentation with citations.

Commands

/commitCreate git commits with user approval and no Claude attribution /create_planYou are tasked with creating detailed implementation plans through an interactive, iterative process. You should be skeptical, thorough, and work collaboratively with the user to produce high-quality technical specifications./describe_prGenerate comprehensive PR descriptions following repository templates /implement_planYou are tasked with implementing an approved technical plan from `thoughts/shared/plans/`. These plans contain phases with specific changes and success criteria./iterate_planIterate on existing implementation plans with thorough research and updates /research_codebaseYou are tasked with conducting comprehensive research across the codebase to answer user questions. You will spawn one or more parallel sub-agents to perform your reserach.

Show all 35 commands

/research_webConduct extensive web research on technical topics with validated references /create-prpGenerate a complete PRP for general feature implementation with thorough research. Ensure context is passed to the AI agent to enable self-validation and iterative refinement. Read the feature file first to understand what needs to be created, how the examples provided help, and /fix-bugSystematically debug issues through hypothesis-driven logging, analysis, and PRP generation./implement-planExecute implementation from plan file /codebaseFix all TypeScript type errors and ESLint warnings in parallel using multiple specialized agents /local-changesFix linting and type errors in files changed on the current branch, with sequential resolution /update-claude-docs**Automatically update all CLAUDE.md files with current codebase patterns.**/validate-codebase-docsValidate and update documentation by comparing against current codebase and recent changes using parallel agents /medium-planGenerate a complete PRP-style medium plan for general feature implementation with thorough research. Ensure context is passed to the AI agent to enable self-validation and iterative refinement. Read the feature file first to understand what needs to be created, how the examples /deep**Comprehensive read-only analysis for large features and architectural changes.**/medium**Read-only quality check - determines if refactor is needed.**/refactor-full**Comprehensive refactor analysis that runs all refactor commands and merges results.**/simple**Read-only code quality analysis for small to medium changes.**/review-planReview an implementation plan for simplification opportunities, gaps, bugs, and better approaches./review-prpReview an implementation plan for simplification opportunities, gaps, bugs, and better approaches./allRun comprehensive code review spawning parallel agents for each of the 11 core principles /antipatternsCheck for anti-patterns and convention violations /architecture-backendCheck for backend architecture pattern violations /architecture-frontendCheck for frontend architecture pattern violations /circular-depsCheck for circular dependencies and late imports /clarityCheck for violations of the Clarity and Readability principle /documentationCheck for documentation standards violations /reuseCheck for violations of the Reuse Over Recreation principle /scopeCheck for violations of the Correct Scope principle /self-containedCheck for violations of the Self-Contained Components principle /single-patternCheck for violations of the Single Way to Do Things principle (MOST IMPORTANT)/tanstack-queryCheck for TanStack Query pattern violations (query keys, optimistic updates, cache seeding)/simple-planCreate a simple plan to address a user question./prp_basename: "Base Medium Plan Template - Context-Rich and Fast" description: |

README

Read on GitHub

Quick install (recommended)

Mac / Linux

Windows (PowerShell)

Bypasses the macOS Gatekeeper / Windows SmartScreen prompts on direct downloads.

or download the installer directly

Installation · What Flying Feels Like · Remote Pane · Pane Chat · Agent-Operable CLI · Keyboard Shortcuts · Building from Source

Not an IDE. Not a terminal emulator. Vim for agent management.

Pane manages AI coding agents without replacing them. If it runs in a terminal, it runs in Pane — instantly, with zero integration. Claude Code, Codex, Aider, Goose, or any CLI tool. No plugins, no SDK, no waiting for support.

Why Pane Exists

AI coding agents are incredible. Claude Code can work autonomously for hours. Codex can ship features end-to-end. Aider can refactor entire modules. The models are not the bottleneck.

The way you interact with them is.

Managing AI agents right now feels like air traffic control with a walkie-talkie. You're juggling terminal windows. Copy-pasting between tabs. Losing track of which agent is on which branch. Alt-tabbing between your diff viewer, your terminal, your git client, and your editor. The agents are fast — but your tools make you slow.

And then there's git worktrees. Everyone agrees worktrees are the right way to run parallel agents — isolated branches, no conflicts, clean separation. But actually using them? It's miserable. git worktree add, git worktree remove, remembering paths, tracking which worktree is on which branch, cleaning up stale ones, rebasing back to main, squashing commits before merging. Even experienced developers fumble the workflow. It's powerful infrastructure with terrible UX.

Pane makes worktrees invisible. You create a session, Pane creates the worktree. You delete a session, Pane cleans it up. You hit a shortcut, Pane rebases from main. You never type git worktree again. All the isolation benefits, none of the pain.

What Flying Feels Like

Each of these is a small thing. Together they compound fast.

Feature
Pane Chat	A global orchestrator terminal that starts in the Pane data directory, loads local Pane orchestration skills, and can coordinate Claude or Codex across repositories, panes, tabs, worktrees, and review loops.	Details
Remote Pane	Run panes, worktrees, terminals, files, git state, and approval prompts on a self-hosted remote machine while controlling them from desktop Pane or the browser app at runpane.com/app.	Setup
Agent-Operable CLI	Pane ships with `runpane agent-context`, `runpane repos add`, and `runpane panes create`, so a coding agent can discover Pane's command schema, register a repo, and open follow-up panes for issues or tasks.	Contract
@mention Terminals	Type `@` in any terminal to pull the last 500 lines from another pane's terminal directly into your context, no copy-paste required.
Clipboard Shortcuts	`Ctrl+Alt+[key]` pastes any saved text snippet instantly, so your most-used prompts are one keystroke away forever.
Terminal Popover	Highlight any text in a terminal and an intelligent popover offers the right action: copy, open in browser, or show in explorer.
Built-in Browser	Preview any URL in a tab next to your terminals so every pane can see its own running dev server without alt-tabbing.
Resource Manager	Built-in CPU and memory monitor broken down per pane and per process, so you can catch a runaway agent before it eats your laptop.
Status Cues	Every AI pane reports its state at a glance — a red dot when an agent is blocked waiting on your approval, an amber pulse while it works, and a "done" cue when it finishes while you're looking elsewhere. The same rollup colors the project dots and pane tabs, so a whole screen of parallel agents reads in one glance.
Jump + Refresh	Jump to top, jump to bottom, or hard-refresh any terminal from the toolbar to unstick a frozen state in one click.
Auto Secrets Copy	Every pane automatically mirrors `.env` files and secrets from your root project so your worktree is runnable the moment it's created.
Isolated Ports	Each pane runs on its own port range automatically, so you can spin up five dev servers in parallel without a single conflict.
Terminal Rendering Patches	Claude Code's scroll-jump bug (long conversations snapping to top when you scroll up) is fixed here, even though it's still broken in Claude Code itself.
Drag and Drop	Drop any file up to 50MB into a terminal and it lands exactly where you need it.

Remote Pane

Run agents on a VM, WSL box, home server, desktop, Mac mini, or cloud machine while you keep the Pane UI on your laptop or phone. Remote Pane is self-hosted and open source: the host machine runs the repos, terminals, git state, files, agent credentials, and compute; the client just connects with a pane-remote://... code.

The easiest setup path is in the app:

Install Pane normally on the machine that should host your projects and agents.
Open Settings > Remote Pane on that host machine.
Set it up as a remote host and copy the generated pane-remote://... connection code.
On another desktop, open Pane, go to Settings > Remote Pane, paste the code, and connect.
On a phone or tablet, open runpane.com/app, paste the same code, and connect.

For a headless VM or server, use runpane:

npx --yes runpane@latest install daemon --label "My Server"

pnpm:

pnpm dlx runpane@latest install daemon --label "My Server"

Python tools:

pipx run runpane install daemon --label "My Server"

Use SSH instead of Tailscale:

npx --yes runpane@latest install daemon --label "My Server" --prefer-tunnel ssh

The hosted shell installers remain available:

curl -fsSL https://runpane.com/install-remote.sh | sh -s -- --label "My Server"

Windows PowerShell:

& ([scriptblock]::Create((irm https://runpane.com/install-remote.ps1))) -Label "My Server"

The CLI setup command prints the same connection code and, for SSH mode, the forwarding command. See the Remote Daemon docs for the full step-by-step setup, mobile install instructions, API key notes, and security model.

Pane Chat

Pane Chat is the global orchestrator terminal for a Pane workspace. It is not tied to a repository or worktree. It starts from the Pane data directory, reads a generated local runtime context, and uses the runpane CLI to inspect and operate the workspace.

Use it for the work that spans panes:

Add this repo, create three worktree panes for the next features, start Codex in each one, and keep a separate review tab ready for every PR.

Pane Chat keeps the human discussion at the orchestrator level, distills that into concrete briefs when needed, then delegates authorized lifecycle stages to Claude or Codex panels through RunPane. The active agent's cached runpane-orchestrator is the canonical source for the software-work lifecycle, authorization ledger, review-feedback interrupts, current-head evidence rules, and ready_to_merge predicate. Pane's generated layer stays focused on the local Pane runtime, skill cache paths, pane/panel/worktree mechanics, and preserving the user's focus.

The prompt stays small because Pane writes local project-level skills into the Pane data directory:

.codex/skills/pane-orchestrator/SKILL.md
.claude/skills/pane-orchestrator/SKILL.md
skills/pane-chat/runpane-orchestrator.md
skills/pane-chat/runtime-context.md

Pane also caches the important workflow skills from the Pane skills repository, including discussion, plan/simple-plan, implement, implementation-reviewer, PR test automation, prepare-pr, gh-address-comments, investigate, and commit. The generated orchestrator skill tells Pane Chat to load the workflow map and local skill cache before it coordinates work, while deferring lifecycle policy to the cached active-agent runpane-orchestrator so Pane does not maintain a second, drifting copy of the workflow.

The top-right toggle switches Pane Chat between Claude and Codex and persists the default orchestrator agent in Pane settings. Both agents share the same Pane-specific orchestration contract, then follow their own cached downstream skills where the Codex and Claude skill surfaces differ.

Agent-Operable CLI

Pane is not just a place where agents run. It exposes a stable runpane CLI contract that agents can use to manage the workspace for you.

For example, you can ask an agent to create panes for a set of GitHub issues and start Codex, Claude Code, or any terminal command in each one. The agent can inspect the available Pane commands, register the current repository if needed, and create panes with initial instructions:

runpane agent-context
runpane repos list --json
runpane repos add --path /path/to/repo --yes --json
runpane panes create --repo active --name issue-252 --agent codex --prompt "Kick off the discussion skill for issue 252" --yes

runpane agent-context is token-efficient by default and prints only command names, arguments, and safe usage notes. Agents can lazy-load full details for a specific command with runpane agent-context --command "panes create" --json.

Pane can also manage a short AGENTS.md block in saved repositories so agent CLIs know the developer is using Pane and can discover the CLI contract without bloating their context.

See Runpane CLI Contract for the full schema and automation examples.

How It Works

Two primitives: panes and tabs. One pane per feature, one worktree each. Inside every pane, everything lives in tabs — agents, diff viewer, file explorer, git tree, logs, multiple terminals. Create a pane, get an isolated workspace. Delete a pane, everything cleans up. Your agents never step on each other, and every tab persists across restarts.

Your agents already talk to Linear, Jira, GitHub, and Slack through MCPs and CLI tools. The terminal is the universal integration layer. Pane doesn't re-integrate what your agents already access — it gives them a place to run.

Pane also lets those agents operate the workspace itself. With the runpane CLI, an agent can list saved repositories, register a new repo, create panes, open terminal-backed agent tabs, and seed the first prompt. That means "set up panes for these issues and start the discussion skill" can be one instruction, not a manual UI checklist.

Other tools build custom chat UIs that only work with agents they've explicitly added support for. Pane gives every agent a real terminal. "Future CLI agent support" isn't a roadmap item here — it's the default. You bring the agents, Pane makes them fly.

Keyboard Shortcuts

Shortcut	Action
`⌘⇧P` / `Ctrl+Shift+P`	Open command palette
`⌘K` / `Ctrl+K`	Clear terminal scrollback
`⌘N` / `Ctrl+N`	New pane
`⌘⇧W` / `Ctrl+Shift+W`	Archive pane
`⌘1-9` / `Ctrl+1-9`	Switch pane
`⌘,` / `Ctrl+,`	Open settings
`⌘⌥<key>` / `Ctrl+Alt+<key>`	Paste a clipboard shortcut into the active terminal
`⌘⌥/` / `Ctrl+Alt+/`	Open Settings → Shortcuts
`⌘⌥` (hold) / `Ctrl+Alt` (hold)	Show all configured shortcuts as an overlay
`Ctrl+B`	Toggle sidebar

Installation

Quick Install

Run the guided setup:

npx --yes runpane@latest

The wizard can install Pane on this machine, configure this machine as a remote host, update Pane, or run diagnostics.

Package Manager Commands

Explicit desktop install:

npx --yes runpane@latest install client
pnpm dlx runpane@latest install client
pipx run runpane install client

Persistent npm install:

npm i -g runpane
runpane setup

Shell Installers

Mac / Linux shell installer:

curl -fsSL https://runpane.com/install.sh | sh

Windows PowerShell installer:

irm https://runpane.com/install.ps1 | iex

Direct Download

Download the Latest Release

Platform	File
Windows (x64)	`Pane-x.x.x-Windows-x64.exe`
Windows (ARM64)	`Pane-x.x.x-Windows-arm64.exe`
macOS (Universal)	`Pane-x.x.x-macOS-universal.dmg`
Linux (x64)	`Pane-x.x.x-linux-x86_64.AppImage` or `.deb`
Linux (ARM64)	`Pane-x.x.x-linux-arm64.AppImage` or `.deb`

Requirements

Git installed and available in PATH
At least one AI coding agent CLI installed:
- Claude Code — npm install -g @anthropic-ai/claude-code
- Codex — npm install -g @openai/codex
- Aider — pip install aider-chat
- Goose — or any other CLI agent

Usage

Open Pane and create or select a project (any git repository)
Create a pane — enter a prompt and pick your agent
Add tabs — launch a Claude terminal, Codex terminal, diff viewer, file explorer, or any CLI tool
Work in parallel — create multiple panes for different approaches
Review diffs — see what changed with the built-in diff viewer
Ship — commit, rebase, and merge from keyboard shortcuts

The Windows Problem

The Windows developer experience for AI coding tools is broken across the board:

Claude Desktop on Windows crashes repeatedly. Requires manual Hyper-V and Container feature enablement. Windows App Runtime dependencies aren't auto-installed.
Claude Code on Windows is non-functional when your Windows username contains a period — standard in enterprise Active Directory environments.
Conductor is Mac-only. No Windows version exists. The founder publicly said Windows support is "hopefully soon-ish."
Claude Squad has a hard dependency on tmux, which doesn't exist on Windows.
Claude Code Agent Teams requires tmux or iTerm2 for split panes. Explicitly not supported in VS Code terminal or Windows Terminal.

Windows has roughly 70% of the developer desktop market. Linux has another 5-10%. Mac has about 25%. The entire AI coding tool ecosystem is building for that 25%.

Pane is for the other 75%. And for Mac developers who want to choose their own agents.

Who Pane Is For

Developers on any OS: Mac, Windows, and Linux are all first-class citizens, with no "Mac-first with a Windows waitlist"
Multi-agent users who run Claude Code, Codex, Aider, or Goose depending on the task and want one app to manage them all
Keyboard-driven developers who want Superhuman-level speed in their AI-assisted coding workflow
Teams where different engineers use different agents and need a consistent workflow layer
Anyone tired of juggling terminal windows, alt-tabbing between diff viewers and git clients, or waiting for agents one at a time

What Pane Is Not

Pane is not your editor. Not your terminal. Not your agent.

It replaces the chaos. The twelve terminal windows. The alt-tabbing. The mental overhead of tracking which agent is on which branch. The frustration of tools that don't work on your OS.

Pane replaces the mess with a single, fast, keyboard-driven surface. It's the thing you wish tmux was.

How Pane Is Different

	Pane	Superset	Conductor	Claude Squad	Cursor/Windsurf
Platform	Win + Mac + Linux	Mac (unofficial Win/Linux)	Mac (Apple Silicon only)	Unix (tmux)	Win + Mac
Agents	Any CLI	Any CLI	Claude + Codex	Any (tmux)	Built-in only
Diff Viewer	Built-in, syntax-highlighted	Built-in	Built-in	None	Editor-level
Git Workflow	Commit, push, rebase, squash, merge — all keyboard	Worktrees + merge	Worktrees + PR	Worktrees only	Editor-level
Keyboard-First	Every action	Partial	Partial	Terminal only	IDE shortcuts
Open Source	Yes (AGPL-3.0)	Yes (Apache-2.0)	No	Yes	No
Session Persistence	Yes	Yes	Yes	No	N/A

Every tool in the AI coding space either only works on Mac, only works with one agent, is a terminal hack that requires tmux, treats Windows as an afterthought, or wants to be your editor, your terminal, and your agent all at once.

Pane is the only tool that is a real desktop app, agent-agnostic, cross-platform with every OS as a first-class citizen, keyboard-first, and git-native. That combination doesn't exist anywhere else.

FAQ

"Isn't this just tmux with extra steps?" tmux is from 2007. Pane is a modern desktop app with a built-in diff viewer, file explorer, git workflow, command palette, browser tab, resource manager, persistent state, cross-terminal context sharing, and (unlike tmux) it works on Windows. tmux is a terminal multiplexer; Pane is a workstation for managing AI coding agents.

"What if a new AI agent comes out tomorrow?" You just run it. Pane doesn't bundle agents or lock you in. If it runs in a terminal, it runs in Pane, instantly. No plugins, no SDK, no waiting for support.

"Do I have to know how git worktrees work?" No. Pane creates and tears down worktrees automatically when you create or delete a pane, so you get all the isolation benefits without ever typing git worktree.

"Can I run multiple agents in parallel without them stepping on each other?" Yes. Each pane gets its own worktree, its own port range, and its own copy of your secrets. Five agents, five isolated workspaces, zero conflicts.

"Why is it called Pane?" Because you look through a pane to see what's happening. Each pane is a window into an agent's work.

"Why Electron?" Pane uses xterm.js, the same terminal engine that powers VS Code's integrated terminal. Same rendering, same reliability, with 50,000 lines of scrollback. Electron also powers VS Code, Slack, Discord, and Figma.

Building from Source

git clone https://github.com/dcouple/Pane.git
cd Pane
pnpm run setup
pnpm run electron-dev

Production Builds

pnpm build:win:x64    # Windows (x64)
pnpm build:win:arm64  # Windows (ARM64)
pnpm build:mac        # macOS (Universal)
pnpm build:linux  # Linux (x64 + ARM64)

Releasing

pnpm run release patch   # 0.0.2 -> 0.0.3
pnpm run release minor   # 0.0.2 -> 0.1.0
pnpm run release major   # 0.0.2 -> 1.0.0
pnpm run release 2.2.1   # explicit version when package.json and tags diverge

Run releases only from a clean main checkout that matches origin/main. The release script refuses inferred bumps when package.json and the latest v* tag disagree; use an explicit version after deciding the intended next release. See Release Instructions for the workflow and required GitHub checks.

License

AGPL-3.0 — Free to use, modify, and distribute. If you deploy a modified version (including as a service), you must open source your changes.

File tree

755

dcouple/PaneView on GitHub

.claude/
  agents/
    codebase-explorer.md
    implementation-reviewer.md
    implementer.md
    plan-reviewer.md
    research-dossier-writer.md
    researcher.md
  commands/
    parsa/
      cl/
        commit.md
        create_plan.md
        describe_pr.md
        implement_plan.md
        iterate_plan.md
        research_codebase.md
        research_web.md
      create-prp.md
      fix-bug.md
      implement-plan.md
      linter/
        codebase.md
        commit.md
        local-changes.md
        update-claude-docs.md
        validate-codebase-docs.md
      medium-plan.md
      refactor/
        deep.md
        medium.md
        refactor-full.md
        simple.md
      review/
      review-plan.md
      review-prp.md
        all.md
        principles/
          antipatterns.md
          architecture-backend.md
          architecture-frontend.md
          circular-deps.md
          clarity.md
          documentation.md
          reuse.md
          scope.md
          self-contained.md
          single-pattern.md
          tanstack-query.md
      simple-plan.md
      templates/
        prp_base.md
  hooks/
    block-terraform-destructive.sh
  settings.json
  skills/
    commit/
      SKILL.md
    create-plan/
      plan_base.md
      SKILL.md
    discussion/
      SKILL.md
    implement/
      SKILL.md
    investigate/
      SKILL.md
    prepare-pr/
      SKILL.md
    research-web/
      SKILL.md
    review/
      CRITERIA.md
      SKILL.md
    share-fix/
      SKILL.md
    simple-plan/
      SKILL.md
  statusline-command.ps1
  statusline-command.sh
.codex/
  config.toml
  skills/
    codebase-explorer/
      SKILL.md
    commit/
      SKILL.md
    discussion/
      SKILL.md
    implement/
      SKILL.md
    implementation-reviewer/
      SKILL.md
    implementer/
      SKILL.md
    investigate/
      SKILL.md
    plan/
    plan-reviewer/
      SKILL.md
      plan_base.md
      SKILL.md
    prepare-pr/
      SKILL.md
    research-web/
      SKILL.md
    researcher/
      SKILL.md
    simple-plan/
      SKILL.md
.dockerignore
.eslintignore
.gitattributes
.github/
  pr-assets/
    electron-324-before-after.png
  pull_request_template.md
  workflows/
    build.yml
    deploy-remote-pwa-preview.yml
    nightly-release.yml
    notify-website.yml
    quality.yml
    traffic-snapshot.yml
.gitignore
.node-version
.npmrc
.nvmrc
AGENTS.md
assets/
  readme-remote-pane.png
  screenshot-dark.png
briefs/
  wsl-performance-bg-cost.md
build/
  afterSign.js
  entitlements.mac.plist
CHANGELOG.md
CLAUDE.md
cloud/
  scripts/
    setup-cloud.sh
    setup-vm.sh
  terraform/
    .gitignore
    gcp/
      .terraform.lock.hcl
      main.tf
contracts/
  runpane/
    contract.json
    README.md
    schema.json
CONTRIBUTING.md
deploy/
  remote-pwa/
    Dockerfile
    nginx.conf
docs/
  ADDING_NEW_CLI_TOOLS.md
  ANALYTICS_INVARIANTS.md
  ANALYTICS_UI_EVENTS_INTEGRATION.md
  BUILDING_ON_WINDOWS.md
  CONFIG_FILES.md
  CRYSTAL_ARCHITECTURE.md
  DATABASE_DOCUMENTATION.md
  FEATURE_USAGE_TRACKING_INTEGRATION.md
  IMPLEMENTING_NEW_CLI_AGENTS.md
  LICENSE-COMPATIBILITY.md
  RELEASE_INSTRUCTIONS.md
  remote-daemon-lifecycle.md
  remote-pwa-safari-debug-handoff.md
  research/
    CLOUD_VM_PRD.md
    CLOUD_VM_RESEARCH.md
  RUNPANE_CLI_CONTRACT.md
  SELF_HOSTED_REMOTE_DAEMON.md
  SESSION_OUTPUT_SYSTEM.md
  STATE_MANAGEMENT.md
  TIMESTAMP_HANDLING.md
  TOOL_PANEL_SYSTEM.md
  troubleshooting/
    DIFF_VIEWER_CSS.md
    SETUP_TROUBLESHOOTING.md
    WINDOWS_CLAUDE_CODE_SPAWN.md
frontend/
  eslint.config.js
  index.html
  package-lock.json
  package.json
  postcss.config.js
  public/
    apple-touch-icon.png
    favicon-96x96.png
    favicon.ico
    favicon.svg
    fonts/
      SymbolsNerdFontMono-Regular.woff2
    pane-logo-dark.svg
    pane-logo-light.svg
    pane-logo.svg
    remote-manifest.webmanifest
  remote.html
  src/
    App.tsx
    assets/
      pane-logo-dark.svg
      pane-logo-light.svg
      pane-logo.png
      pane-logo.svg
    components/
      AboutDialog.tsx
      AddProjectDialog.tsx
      AnalyticsConsentDialog.tsx
      ArchiveProgress.tsx
      CloneFromGitHubDialog.tsx
      CloudOverlay.tsx
      CloudWidget.tsx
      CommandPalette.tsx
      CommitDialog.tsx
      ConfirmDialog.tsx
      CreateSessionButton.tsx
      CreateSessionDialog.tsx
      dashboard/
        MultiOriginStatus.tsx
        StatusSummaryCards.tsx
      DetailPanel.tsx
      dialog/
        BaseAIToolConfig.tsx
        ClaudeCodeConfig.tsx
        CodexConfig.tsx
      DiscordPopup.tsx
      DocsDialog.tsx
      EmptyState.tsx
      ErrorBoundary.tsx
      ErrorDialog.tsx
      ExecutionList.tsx
      FileList.tsx
      FilePathAutocomplete.tsx
      GitHistoryGraph.tsx
      GitStatusIndicator.tsx
      Help.tsx
      HomePage.tsx
      LoadingSpinner.tsx
      MainBranchWarningDialog.tsx
      MainProcessLogger.tsx
      MarkdownPreview.tsx
      MermaidRenderer.tsx
      MonacoErrorBoundary.tsx
      NotificationSettings.tsx
      OnboardingDialog.tsx
      PaneChatView.tsx
      panels/
        browser/
          BrowserPanel.tsx
          BrowserSurface.tsx
        cli/
          BaseCliPanel.tsx
          CliPanelFactory.tsx
        DashboardPanel.tsx
        diff/
          CombinedDiffView.tsx
          DiffPanel.tsx
          DiffViewer.tsx
          reviewModePreference.test.ts
          reviewModePreference.ts
        editor/
          EditorPanel.tsx
          FileEditor.tsx
          NotebookPreview.tsx
        logPanel/
          LogsPanel.tsx
          LogsView.tsx
        PanelContainer.tsx
        PanelGroupView.tsx
        PanelLoadingFallback.tsx
        PanelTabBar.tsx
        PanelTabStatusDot.tsx
        PanelTabStrip.tsx
        SetupTasksPanel.tsx
        SplitLayout.tsx
        TerminalPanel.tsx
      PermissionDialog.tsx
      ProjectDashboard.tsx
      ProjectDashboardSkeleton.tsx
      ProjectSelector.tsx
      ProjectSessionList.tsx
      ProjectSettings.tsx
      ProjectView.tsx
      PromptDetailModal.tsx
      ResizablePanel.tsx
      ResumeSessionsDialog.tsx
      RunScriptConfigDialog.tsx
      session/
        CommitMessageDialog.tsx
        FolderArchiveDialog.tsx
        GitErrorDialog.tsx
        ThinkingPlaceholder.tsx
      SessionDetailTooltip.tsx
      SessionStatusBadge.tsx
      SessionView.tsx
      settings/
      Settings.tsx
        catalog.tsx
        categories/
          AdvancedSettings.tsx
          AIAgentsSettings.tsx
          AppearanceSettings.tsx
          GeneralSettings.tsx
          IntegrationsSettings.tsx
          PrivacySettings.tsx
          RemoteAccessSettings.tsx
          ShortcutsSettings.tsx
          TerminalSettings.tsx
          WorktreesGitSettings.tsx
        RemoteAccessWorkflows.tsx
        SecretField.tsx
        SettingRow.tsx
        SettingsControls.tsx
        SettingsLayout.tsx
        useDirtySettingsForms.ts
        useRemoteAccessSettings.ts
        useSettingsPersistence.ts
      ShortcutHintsOverlay.tsx
      Sidebar.tsx
      StatusIndicator.tsx
      terminal/
        hooks/
          useTerminalLinks.ts
        InterceptorDropdown.tsx
        InterceptorToast.tsx
        linkProviders/
          fileLinkProvider.ts
          gitLinkProvider.ts
          index.ts
          types.ts
        SelectionPopover.tsx
        TerminalLinkTooltip.tsx
        TerminalPopover.tsx
        TerminalSearchOverlay.tsx
      ui/
        AgentStatusDot.tsx
        agentStatusVisual.test.ts
        agentStatusVisual.ts
        Badge.tsx
        BrandIcons.tsx
        Button.tsx
        Card.tsx
        CollapsibleCard.tsx
        CopyableField.tsx
        Dropdown.tsx
        dropdownNavigation.test.ts
        dropdownNavigation.ts
        EnhancedInput.tsx
        FieldWithTooltip.tsx
        IconButton.tsx
        Input.tsx
        Kbd.tsx
        LiveRegion.tsx
        Modal.tsx
        Pill.tsx
        Select.tsx
        SettingsSection.tsx
        StatusAccentBar.tsx
        StatusDot.tsx
        Switch.tsx
        SwitchSimple.tsx
        Textarea.tsx
        Toggle.tsx
        TogglePillImproved.tsx
        Tooltip.tsx
      UpdateDialog.tsx
      Welcome.tsx
    contexts/
      ContextMenuContext.tsx
      PortalContainerContext.tsx
      SessionContext.tsx
      ThemeContext.tsx
    hooks/
      useAgentStatus.ts
      useAIInputPanel.ts
      useCliPanel.ts
      useHotkey.ts
      useIPCEvents.ts
      useNotifications.ts
      usePaneLogo.ts
      useResizable.ts
      useResizableHeight.ts
      useResizablePanel.ts
      useResourceMonitor.ts
      useSessionNavigationHotkeys.ts
      useSessionView.ts
      useShortcutHintsOverlay.ts
      useTerminalSearch.ts
      useTerminalShortcuts.ts
    index.css
    main.tsx
    remote/
      components/
        RemoteConnectionScreen.tsx
... 485 more

FAQ

pane is a Claude Code plugin with 10 hand-picked skills for development work, indexed on Flowy. Install it with the command on its page. It includes commit, create-plan, discussion. Its skills do not fire on their own yet. Request auto-invocation to have Flowy route them as you prompt. Free and open source.

What is pane?: pnpm dlx runpane@latest
How do I install pane?: Run these in Claude Code: npx -y skills add dcouple/Pane --agent claude-code. Then prompt normally.
Does pane auto-invoke its skills?: Not yet. It is indexed on Flowy as a plain plugin. Request auto-invocation on its page and Flowy will route its skills for you as you prompt.
Is pane free?: Yes. Flowy is free and open source, with nothing gated. You can read every skill in full before you install.