Portable Developer Profile (/export-profile / /import-profile)

Preflight Checklist

• [x] I have searched existing requests and this feature hasn't been requested yet
• [x] This is a single feature request (not multiple features)

Related issues: #18645 and #33064 address session/conversation portability between machines and projects.

This request is different — it focuses on exporting the developer's configuration profile (coding principles, hooks, skills, MCP configs) as a reusable bundle, and introduces conventions as an active coaching mechanism during pairing sessions.

Problem Statement

As developers invest time configuring Claude Code to understand their coding style, quality gates, and workflow preferences, that configuration becomes scattered across multiple files and locations:

• ~/.claude/CLAUDE.md (global instructions)
• ~/.claude/settings.json (global settings, MCP servers)
• .claude/ project directory (hooks, local settings)
• Custom skills
• Memory and learned preferences

There's no unified way to:

• Export this accumulated configuration as a portable bundle
• Import it into a new project or a fresh machine
• Share a team baseline while allowing individual customisation
• Version the full profile as a single artefact

Developers who work across multiple projects or machines end up manually recreating or copy-pasting configuration, which is error-prone and time-consuming.

Beyond configuration portability, teams maintain coding conventions in wikis and docs, but in practice:

• People forget — conventions get written once and gradually ignored
• Claude Code also drifts — without persistent reinforcement, it stops applying standards consistently over long sessions
• Onboarding is slow — new team members read the wiki once and learn the real conventions through code review friction

There's no mechanism for Claude Code to actively enforce and coach against agreed team standards.

Proposed Solution

Part 1: /export-profile and /import-profile

/export-profile bundles the developer's Claude Code configuration into a single portable file (e.g., .claude-profile.json or a .claude-profile/ directory):

/export-profile myProfile

Included in the export:

• Global and project CLAUDE.md content (with clear labelling of scope)
• Hooks configuration
• Custom skills
• MCP server definitions
• Settings and permissions
• Optionally, memory/learned preferences

Options:

• --scope global|project|all — control what gets exported
• --exclude hooks,memory — skip specific sections
• --output ./path — export location

/import-profile applies a previously exported profile to the current environment:

/import-profile myProfile

Options:

• --scope global|project — where to apply
• --merge — merge with existing config (default) vs --replace
• --dry-run — preview what would change before applying
• --skip hooks,mcp — selectively import

Part 2: /conventions — Living Coding Conventions as a Coaching Tool

A command that generates and maintains a human-readable coding conventions document (markdown wiki) derived from the team's profile, CLAUDE.md, and observed patterns:

/conventions generate    # Draft conventions wiki from current profile
/conventions check       # Audit current code against conventions
/conventions coach       # Flag deviations during pairing, suggest fixes

What this enables:

• Single source of truth — the conventions doc is both human-readable (for the wiki) and machine-enforceable (by Claude Code)
• Active coaching — during a pairing session, Claude Code doesn't just follow the rules, it reminds the developer when they're drifting ("This breaks our convention on X — here's why we do it differently")
• Self-healing consistency — when Claude Code itself starts drifting in a long session, the conventions act as a reset anchor
• Reduced code review friction — conventions are enforced at authoring time, not review time

Alternative Solutions

1. Dotfiles-style Git repo — maintain a personal repo with CLAUDE.md, hooks, skills, and a shell script that symlinks or copies files into ~/.claude/ and project .claude/ directories. This works but is fragile, manual, doesn't cover memory, and requires each developer to maintain their own scaffolding.

1. Copy-paste between projects — manually duplicate .claude/ folders and CLAUDE.md files. Error-prone, diverges quickly, no versioning.

1. CLAUDE.md-only approach — put everything in the global CLAUDE.md and hope it's enough. Doesn't cover hooks, skills, MCP configs, or active enforcement.

1. Team wikis + code review — document conventions in Confluence/Notion and enforce them through manual PR reviews. High friction, relies on human reviewers catching every deviation, and doesn't help during authoring.

None of these approaches provide a unified, portable, actively-enforced developer profile.

Priority

Medium - Would be very helpful

Feature Category

Configuration and settings

Use Case Example

1. New machine setup — developer gets a new laptop, imports their profile, and Claude Code immediately knows their standards (SOLID, TDD, clean code conventions, preferred frameworks).

1. Multi-project consistency — a developer working across several repos applies the same quality gates and coding principles everywhere without per-project duplication.

1. Team onboarding — a team maintains a shared base profile covering agreed conventions (testing strategy, architecture patterns, code style), which new members import and extend with personal preferences.

1. CI/CD integration — a profile can be committed to a repo so automated Claude Code usage in pipelines follows the same standards as local development.

1. Better pairing — the developer teaches Claude Code once, Claude Code coaches the developer back. A genuine feedback loop rather than a one-way configuration.

Additional Context

A first-class profile mechanism would make Claude Code's personalisation a genuine competitive advantage — developers invest in teaching it once, and that investment compounds across every project and every team member.