Guides
Profiles and sharing
The Profiles tab lists your profiles with their command, folder and how many conversations, projects and memories each has. From here you create, edit and delete profiles, start one from a template, choose what each profile shares with the source profile, and turn on profile by folder.
Claude accounts
Above the profiles, Claude accounts has a card for each claude.ai account the profiles are signed in to (one per organization): the name, email, organization and role, the plan (such as Max 5× or Team), since when you are a member and subscribed, whether extra usage is on, and the profiles that use it. A profile whose sign-in is gone, as after /logout, says so: log in again there with /login. Profiles signed in to no account are listed under the cards.
Plan usage limits
On each card, three bars show how much of the plan is used: the 5-hour window, the week, and the weekly limit of a single model when the plan has one, each with the time it resets. A bar turns orange from 75 % and red from 90 %. In the About panel (ⓘ), under cc-profiles settings, Plan limits picks whether the bars show how much is used or how much is left; the colour follows what is used either way, and the choice is kept in the browser.
cc-profiles asks claude.ai the way Claude Code’s /usage does, with the profile’s sign-in (from the macOS keychain, or .credentials.json in the profile folder), and keeps the answer for 5 minutes: under the bars, the time it was checked, and Refresh to ask again now. The token is only read: it never reaches the page and is never stored, copied or refreshed. When it has expired, the row says to open Claude Code in the profile, which refreshes it. The first time, macOS may ask to let cc-profiles read the keychain. A sign-in with an API key, Bedrock or Vertex has no plan limits.
While the page is open, cc-profiles checks the limits every 15 minutes, from any tab. When a limit reaches 90 % it says so once, in a message at the bottom of the page; the Mac app sends a macOS notification instead, also with its window closed, and shows the 5-hour window’s use next to its menu bar icon. Every check also records the day’s highest value of each limit, which the Usage tab draws.
Create a profile
New profile (in the Profiles tab, or the + New profile card at the top) asks for:
- Name: shown in the UI and the status line, for example Work.
- Id: lowercase letters, digits and dashes, for example
work. It defines the folder~/.claude-workand the commandclaude-work. - Base:
- Copy of … copies settings,
CLAUDE.md, skills, plugins, agents, MCP servers and per-project settings from an existing profile. Optionally it also copies conversations, history and project memories. General memories (your home project) are always copied. - From template: … starts from a template: its settings,
CLAUDE.md, permissions, skills, agents, commands, output styles and MCP servers, as the profile’s own copies, except the items you share. No conversation comes along. - Empty starts from scratch, with only the status line setting of the source profile.
- Copy of … copies settings,
- Share with the source profile: which items become links instead of copies. Skills and plugins are ticked by default; with a template only plugins are, so the template’s own skills are used. You can change the choice later, under Sharing.
With a template, an item you share is linked to the source profile instead of being filled from the template: the template’s copy of it is not used. The dialog lists what each shared item skips, for example skills: shared with Default, the template’s 3 skills are not copied, and the confirmation after creating says the same. Templates never hold plugins, so sharing plugins is how a profile created from a template gets the plugins of the source profile.
What a new profile never gets:
- login credentials (
.credentials.json) and account data (oauthAccount,userID): run the new command and use/login. A copied token could be invalidated when the original profile refreshes it. - runtime state: caches, open sessions, telemetry.
cc-profiles also creates the launcher ~/.local/bin/claude-<id> (see Getting started) and adds the /cc-profiles command to the new profile, so you can open this app from it right away. If the profile shares commands with the source profile, the command goes into the source and reaches both through the link. A cc-profiles.md that cc-profiles did not write is left as it is.
Items you choose to share that the source profile does not have yet are created there, empty, so the link always works.
Templates
A template is a reusable starting point for new profiles. Templates… in the Profiles tab lists them and saves a new one from any profile.
A template holds the profile’s settings.json and settings.local.json (with permissions and hooks), CLAUDE.md, skills/, agents/, commands/, output-styles/ and the MCP servers of .claude.json (user scope). It never holds conversations, prompt history, memories, plugins, login credentials (.credentials.json) or account data (oauthAccount, userID). Shared items are saved as real files, so the template does not depend on the source profile.
Templates are .zip files in ~/.cc-profiles/templates/, in the same format as an export without conversations. Creating a profile from a template uses the import code, so paths inside settings.local.json point to the new folder.
Saving, deleting and creating a profile from a template each have a backup. A deleted template goes to the backup and Restore brings it back.
Edit a profile
Edit changes:
- Name: updates the UI and the status line right away.
-
Command: renames the launcher, or rewrites the alias if the profile was set up with a shell alias before. The source profile’s command is
claudeand cannot change. A command that already exists as another program is refused. - Folder:
~/.claude-noabecomes~/.claude-clienti. While you type, the dialog says what follows: the paths Claude Code wrote into the profile’s files (settings.local.json,plugins/*.json,.claude.json), the launcher or alias,config.json, and the links of other profiles into it (shared items, projects, memories). It is refused while a Claude Code session is open in the profile, and for the source profile, whose folder is where Claude Code looks by default. Afterwards log in again with/login: macOS keeps the login in the keychain under a name made from the folder’s path, and cc-profiles never copies a login. One Restore puts the old folder back.
Never rename a profile’s folder in the Finder: the paths in its files, its command and the links of other profiles would still point to the old name.
Delete a profile
Delete offers two options:
- Delete everything: the whole folder goes to the backup.
- First move conversations, memories and history to …: every project with content is moved to another profile, together with the remaining prompt history, and then the folder goes to the backup.
When the profile has conversations or memories, moving them is the option already chosen; pick Delete everything to drop them.
In both cases the profile leaves config.json and its launcher (or shell alias) is removed. Type the profile’s name to enable the button.
The dialog shows what the chosen option does before you confirm: how many projects, conversations, memories and prompts move and where, and under Show the files and folders it touches every item, including the launcher, the alias line in your shell file, the entry in config.json and the folder that goes to the backup. The preview changes nothing.
Deleting is refused:
- for the source profile, because the others share from it;
- while a session is open in the profile (a
claudeprocess is running in the profile, or one of its conversations was written in the last 2 minutes), because a running Claude Code would keep writing into a folder that is gone.
Share items
Under Sharing, each secondary profile has a switch per item:
| Item | What sharing means |
|---|---|
skills |
same local skills everywhere |
plugins |
same installed plugin files (enabling is per profile, in settings.json) |
agents |
same custom subagents |
commands |
same custom slash commands |
CLAUDE.md |
same global instructions |
settings.json |
same settings, status line, enabled plugins, permissions and hooks |
Turning a switch on replaces the profile’s own copy with a link. The old copy goes to the backup, and the confirmation lists anything the source profile does not have, so you can copy it over first. Turning it off gives the profile an independent copy of the current source content.
Both confirmations have Show the files and folders it touches: the own copy that goes to the backup, each item only that copy has, the link and its target, and what is created in the source profile when it does not have the item yet; when separating, the link that goes to the backup and the files copied in its place.
Share everything
Share everything…, at the top of each profile’s card, makes the profile differ from another one only by its Claude account. Pick the other profile in With: the source profile, or any other one. One confirmation lists what happens, and one backup holds all of it, so one Restore undoes it:
skills,plugins,agents,commandsandCLAUDE.mdbecome links to the other profile’s. A link always leads to the real files: if the other profile’s skills are themselves a link to the source profile’s, the link goes there. What only this profile has joins the other first: its own skills, agents and commands move there; one with a name the other has too, if it differs, its ownCLAUDE.mdand its own plugins go to the backup.- Every project of the two profiles becomes a shared project: the same conversations and memories in both. A project only this profile had moves to the other profile’s folder.
- Also
settings.jsonshares permissions, hooks, enabled plugins, model and status line too. It also holds the profile’s GitHub account and commit identity (see below), which then become the other profile’s: the box is ticked by itself when both profiles use the same GitHub account, and the dialog says what changes when they do not.
Projects opened later in one profile only are not shared by themselves: run Share everything again. Then to change account, open Claude Code with the other profile’s command, or use Continue in… to go on with the same conversation.
The item switches show shared with … for an item linked to a profile other than the source; unticking it gives the profile its own copy. A profile whose files others use this way cannot be deleted until they are separated.
A GitHub account per profile
Signing in to GitHub is not part of a Claude Code profile: the GitHub CLI (gh) keeps its sign-in in a folder, ~/.config/gh, shared by everything you run. cc-profiles gives every profile a GitHub CLI folder of its own, named after it:
| Profile | GitHub CLI folder |
|---|---|
Default (~/.claude) |
~/.config/gh, the same as your terminal |
~/.claude-<id> |
~/.config/gh-<id> |
cc-profiles creates the missing folders when it starts, and a new profile gets its own right away. A new folder starts with the account the profile used until then (config.yml and hosts.yml are copied without any token line), and GH_CONFIG_DIR in the env of the profile’s settings.json points to it: Claude Code passes it to every command it runs, so gh in that profile’s sessions uses that folder. The profile cards and the About panel show the account: GitHub as ….
A profile’s folder lists only the account it uses. gh auth status in a session of that profile shows that account alone, and there is no other one to gh auth switch to, so Claude cannot use or pick another account by mistake. cc-profiles keeps it so: when it starts, and when you pick another account for a profile, the other accounts leave that profile’s folder (the file goes to the backup first). They stay listed in Default’s folder or in ~/.config/gh-accounts, so you can still pick them here. Two folders are left as they are: Default’s ~/.config/gh, because it is your terminal’s too, and a folder with a token written in its hosts.yml, where taking an account off would delete its token. This keeps accounts apart, it is not a wall: the tokens are in one system keychain, and a command that sets GH_CONFIG_DIR to another folder uses that folder’s account.
The GitHub section at the bottom of the Profiles tab has a row per profile. As in Settings, what you change there is a draft: changed rows get an orange bar, and Save changes in the bar below the table saves them all in one backup (Cancel drops them).
- GitHub account: pick any account signed in on this computer. It becomes the account of that profile’s folder only, and the one it used leaves the folder, without signing in again:
ghkeeps each account’s token in the system keychain under its name. Picking an account for Default changes your terminal’s too. - Another account… (at the end of the menu) shows the command to sign in with a new account in the profile’s folder, ready to copy:
GH_CONFIG_DIR=~/.config/gh-work gh auth loginThen click I signed in, refresh: from then on every profile can pick that account too. Under the table, Accounts lists every GitHub account signed in on this computer, the profiles that use it and the folders it is in:
- Add account… gives the command to sign in in
~/.config/gh-accounts, a folder no profile uses, so adding an account changes none of them; then pick it in the menu of the profiles you want. -
Remove… takes an account off every folder (they go to the backup first). An account a profile uses cannot be removed until you pick another one there. Its token stays in the system keychain: the confirmation gives the
gh auth logout --hostname github.com --user <name>command to delete it too. An account whose token is written inhosts.ymlis marked token in hosts.yml: sign it out in a terminal. - Commits by: the name and email of the commits made in the profile (
GIT_AUTHOR_*andGIT_COMMITTER_*in itsenv). Every profile has them: left empty, cc-profiles fills them in from its GitHub account, with the name of its public profile (or the user name) and its<id>+<user>@users.noreply.github.comaddress, which GitHub links to the account; the id comes from GitHub’s public API, without a token. Without a connection it uses your git config, or<user>@users.noreply.github.com; without an account, your git config. A profile that has none gets them when cc-profiles starts, and an identity taken from the account follows it when you pick another account; one you wrote yourself stays. Under the fields, Commits go out as shows the name and email saved now, with a ✓ when the email is the account’s address. When it is not, the row says so (not <account>, and whose address it is) with a button, Use <account>’s, that puts the account’s name and address in the fields: an identity changed by mistake shows up there, not later in the history of your projects.
A profile whose settings.json is shared with the source profile also shares its GitHub account, so it has no folder. An account whose token is written in hosts.yml (gh auth login --insecure-storage) is not offered to the other profiles, because its token is not in the keychain; a folder copied from it asks for a sign-in.
For git push to follow the account too, git must ask gh for GitHub passwords: run gh auth setup-git once. The section warns when it is not set up, with a button to copy the command. Changes apply to the profile’s Claude Code sessions, not to your own terminal (except for Default), and an open session picks them up when it restarts. Every change goes to the backup.
cc-profiles reads only which users each folder is signed in as, never a token. Deleting a profile leaves its GitHub CLI folder in place; gh auth logout inside one folder removes that account’s token from the keychain, which signs it out in every folder.
Something wrong, unclear or missing on this page? Open an issue on GitHub