Importing Memories from Other Coding CLIs

Overview

Every coding CLI stores context differently. Claude Code uses CLAUDE.md files and per-project memory directories. Codex stores rules. Gemini keeps a single GEMINI.md file. Autohand's import system reads from these locations and maps the data into its own memory structure.

Memory import is part of the broader import and migration system. While that system handles settings, agents, MCP servers, and skills, this guide focuses specifically on the memory category and how to get the most out of it.

Supported sources

Quick start

The fastest way to import memories is the interactive wizard. It auto-detects which tools are installed and shows you what is available before importing anything.

# Start the import wizard
/import

# The wizard detects installed tools:
# Found: Claude Code, Gemini
#
# Claude Code:
#   memory   3 projects with memory data
#   settings config.json
#   skills   2 custom skills
#
# Gemini:
#   memory   GEMINI.md project memory
#   settings config.json
#
# Select categories to import: [memory]

Select the memory category and the wizard handles the rest. Your original files are never modified or deleted.

Importing from Claude Code

Claude Code stores the richest memory data of any supported tool. It keeps per-project CLAUDE.md files (project instructions) alongside per-project memory directories containing individual memory entries.

What gets imported

• CLAUDE.md - Project-level instructions that tell the agent about your codebase, build commands, conventions, and preferences
• memory/ directory - Individual memory files that capture preferences, corrections, and decisions from past sessions

Source locations

# Claude Code stores project data here
~/.claude/projects/{project-hash}/
  CLAUDE.md          # Project instructions
  memory/            # Per-project memories
    user_role.md
    feedback_testing.md
    project_auth.md

Run the import

# Import only memory from Claude Code
/import claude

# Or from the command line
autohand import claude --categories memory

# Preview first
autohand import claude --categories memory --dry-run

Where it lands

Imported Claude memories are stored in a separate directory so they do not overwrite your existing Autohand memories:

# Imported project memories
~/.autohand/projects/{project-hash}/imported-claude/
  CLAUDE.md
  memory/
    user_role.md
    feedback_testing.md
    project_auth.md

Autohand reads these imported files during session startup just like native memories. The agent sees both your Autohand memories and your imported Claude memories.

Importing from Gemini

Gemini stores a single global instruction file that applies across all projects. This is a simpler structure than Claude Code, but still valuable to bring over.

What gets imported

• GEMINI.md - A global instruction file with your coding preferences, tool conventions, and workflow patterns

Source location

# Gemini stores global instructions here
~/.gemini/GEMINI.md

Run the import

# Import from Gemini
/import gemini

# Or from the command line
autohand import gemini --categories memory

Where it lands

# Imported to user-level memory
~/.autohand/memory/imported-gemini/
  GEMINI.md

Since Gemini's memory is global (not per-project), it is imported to your user-level memory directory. This means it applies across all your projects in Autohand, same as it did in Gemini.

Importing from Codex

Codex stores coding rules as markdown files in a rules directory. The import wizard detects these and reports them under the memory category.

What gets imported

• Rule files - Markdown files in ~/.codex/rules/ that define coding standards and conventions

Source location

# Codex stores rules here
~/.codex/rules/
  typescript.md
  testing.md
  api-design.md

Manual import recommended

The Codex memory importer is still in development. The wizard detects and counts your rule files, but full automated import is not yet available. For now, copy the files manually:

# Copy Codex rules to Autohand user memory
cp -r ~/.codex/rules/ ~/.autohand/memory/imported-codex/

# Or to a specific project
cp -r ~/.codex/rules/ .autohand/memory/imported-codex/

Autohand picks up any markdown files in the memory directory at session start, so manual copies work the same as automated imports.

Manual migration from any tool

If you use a tool that Autohand does not have an automated importer for, you can still bring over your context manually. The memory system reads plain markdown files from well-known directories.

Step 1: Locate your existing instructions

Most coding CLIs store instructions in one of these patterns:

# Common locations to check
~/.cursor/rules          # Cursor rules
~/.cline/instructions    # Cline instructions
~/.continue/config.json  # Continue (instructions embedded in config)
.cursorrules             # Cursor per-project rules
.clinerules              # Cline per-project rules

Step 2: Copy to Autohand memory

Decide whether the instructions are personal (user memory) or project-specific (project memory), then copy them to the right location:

# Personal preferences go to user memory
cp my-coding-rules.md ~/.autohand/memory/imported-rules.md

# Project-specific instructions go to project memory
cp .cursorrules .autohand/memory/cursor-rules.md

Step 3: Review and clean up

Open the imported files and remove any tool-specific references that would not make sense in Autohand. For example:

# Before (Cursor-specific)
When using @codebase, always search for related tests first.
Use the Composer to refactor multi-file changes.

# After (tool-agnostic)
Always search for related tests before making changes.
Use multi-file editing for refactors that span several files.

After importing

Once your memories are imported, a few steps help make sure everything works well.

Verify with /memory

Run /memory to see all loaded memories, including imported ones. This confirms the files are in the right location and being read by the agent.

/memory

# Project memories (.autohand/memory/):
#   1. Use date-fns instead of moment.js
#   2. Follow repository pattern for database access
#
# Imported (Claude):
#   3. Always run tests before committing
#   4. Use conventional commit format
#
# User memories (~/.autohand/memory/):
#   5. Prefer concise commit messages
#
# Imported (Gemini):
#   6. Use TypeScript strict mode in all projects

Resolve conflicts

If you have imported memories from multiple tools, some may contradict each other. For example, Claude memory might say "use Jest" while Gemini memory says "use Vitest". Review for conflicts and remove the outdated one.

Consolidate over time

Imported memories live in separate directories (imported-claude/, imported-gemini/). As you work with Autohand and create new native memories, the imported ones may become redundant. Periodically check /memory and clean out entries that Autohand has already learned through your sessions.

# After a few weeks, clean up imported memories
ls ~/.autohand/memory/imported-gemini/
# If Autohand already knows these preferences natively,
# you can safely remove the imported directory
rm -rf ~/.autohand/memory/imported-gemini/

Memory format reference

For reference, here is how each tool structures its memory data and how Autohand maps it.

Claude Code memory format

# ~/.claude/projects/{hash}/memory/feedback_testing.md
---
name: testing-preferences
description: User prefers integration tests over mocks
type: feedback
---

Run integration tests against a real database, not mocks.

**Why:** Prior incident where mocked tests passed but prod migration failed.
**How to apply:** When writing database tests, always use the test database.

Autohand preserves this frontmatter format. The agent reads the description field to decide which memories are relevant to the current session.

Gemini memory format

# ~/.gemini/GEMINI.md

## Coding Style
- Use TypeScript with strict mode
- Prefer functional programming patterns
- Write tests for all public functions

## Project Conventions
- API endpoints return camelCase JSON
- Use Prisma for database access
- Deploy to Vercel

Autohand reads the full file as a single memory document. Headings and bullet points are preserved and interpreted as structured instructions.

Codex rules format

# ~/.codex/rules/typescript.md

Always use strict TypeScript configuration.
Prefer `interface` over `type` for object shapes.
Use `readonly` for properties that should not be reassigned.
Never use `any` - use `unknown` with type guards instead.

Each rule file is a standalone set of instructions. Autohand treats each file as a separate memory entry.

Troubleshooting

Import wizard does not detect my tool

The wizard looks for tool directories in your home folder (~/.claude, ~/.codex, ~/.gemini). If your tool is installed in a non-standard location, the wizard will not find it. Use the manual migration approach instead.

Imported memories are not showing up

Check that the files were copied to the right directory:

# User-level imported memories
ls ~/.autohand/memory/imported-*/

# Project-level imported memories
ls ~/.autohand/projects/*/imported-*/

If the files exist but /memory does not show them, restart your session. Memories are loaded at session startup.

Imported memories conflict with each other

When importing from multiple tools, conflicting instructions can confuse the agent. The agent prioritizes project memory over user memory, and newer memories over older ones. If you see inconsistent behavior, review your imported files for contradictions and remove the outdated entries.

Imported CLAUDE.md references Claude-specific features

CLAUDE.md files often reference Claude-specific concepts like "artifacts" or Claude model names. These are harmless but can waste context tokens. Edit the imported file to remove or replace tool-specific language with general instructions.

Frequently asked questions