synapptic

synapptic analyzes your AI coding sessions and builds a living profile that your agent loads at the start of every conversation. Not just your preferences - it detects interaction patterns you didn't even notice: the corrections you keep making, the assumptions your AI gets wrong, the workflow quirks that matter to you but you never thought to write down.

The difference between memory files you write yourself (CLAUDE.md, .cursorrules) and what synapptic generates is that you can only document what you're aware of. synapptic sees the patterns underneath - the things that cause friction without you realizing why. It watches fifty sessions and tells your AI: "this person interrupts when you over-investigate, stops reading after the second paragraph, and will lose trust if you claim something without checking the code first."

The result is simple: you stop fighting the model. You stop repeating yourself. You get back into flow - the state where you're thinking about your code, not about how to make yourself understood.

Every synapptic install is personal. No two profiles are alike because no two developers are alike. Your profile reflects your communication style, your expertise, your frustrations, your standards. It's a fingerprint of how you work - built from your actual sessions, not from a template.

Get started

pip install synapptic
synapptic init       # pick your LLM provider and output targets
synapptic install    # set up automatic session processing
synapptic ingest     # analyze your existing sessions

That's it. From now on, every session ends with synapptic quietly learning in the background. The next session starts smarter.

What it builds

After analyzing your sessions, synapptic produces a living document with three sections:

## User Archetype

You are working with a senior full-stack engineer who expects execution,
not explanation. Terse commands, no pleasantries. Read diffs, don't
summarize them.

## Guards

1. NEVER commit without running tests first
2. BEFORE implementing a new service, read an existing one of the same type
3. WHEN the user specifies a verification path, treat it as a hard constraint
4. NEVER write a post-implementation summary

## Known Weaknesses

- Confident claims without evidence
- Scope creep on focused fixes
- Planning theater ("let me plan this" for implementation tasks)

This loads automatically at session start. Your AI already knows the rules before you type a word.

Works with everything

Any LLM provider for processing

Provider	Setup	Cost
Claude CLI	Already authenticated via Claude Code	Uses your plan
Anthropic API	API key	~$0.30-0.80/session
OpenAI API	API key	~$0.20-0.60/session
Ollama	Running locally	Free
LM Studio	Running locally	Free
Custom	Any OpenAI-compatible endpoint	Varies

Any AI coding assistant for output

Assistant	Where synapptic writes
Claude Code	~/.claude/projects/*/memory/user_archetype.md
Cursor	.cursor/rules/synapptic.mdc
GitHub Copilot	.github/copilot-instructions.md
Gemini Code Assist	.gemini/styleguide.md
OpenAI Codex CLI	AGENTS.md
Windsurf	.windsurfrules
Cline	.clinerules
Aider	CONVENTIONS.md
Continue.dev	.continuerules

Use one or all of them. synapptic writes to every target you configure - one command, all your tools stay in sync. Guards are filtered per model based on benchmark results - a guard marked redundant for Claude but effective for Gemini only appears in the Gemini output.

Session sources

synapptic currently reads session transcripts from Claude Code (~/.claude/projects/*/*.jsonl), which stores full conversation history as structured JSONL. The profile it builds from those sessions is universal - the guards, preferences, and patterns apply to any AI assistant, not just Claude.

Support for additional session sources (Cursor chat history, Copilot logs, manual transcript import) is planned.

How it works

Your session transcripts
    ↓ filter (626x compression - keeps only what matters)
Conversation pairs
    ↓ extract (LLM analyzes your interactions)
Raw observations across 9 dimensions
    ↓ merge (weighted accumulation - patterns strengthen, noise fades)
Living profile
    ↓ synthesize (LLM writes the narrative)
Archetype document
    ↓ integrate (writes to your tools)
Claude Code, Cursor, Copilot, Gemini - all updated

What it looks for

synapptic extracts across nine dimensions, split between who you are (global) and what goes wrong in each project:

	Global (follows you everywhere)	Per-project (specific to each codebase)
About you	Communication style, workflow patterns, values, expertise	Code style, expectations
About the AI	Common anti-patterns (promoted from 2+ projects)	Failure patterns, behavioral guards

Patterns that keep appearing across multiple projects automatically promote to global. A guard that started in one project becomes universal once the AI makes the same mistake in another.

It gets smarter over time

• Weighted decay: Patterns that keep appearing get stronger. Old patterns that stop appearing naturally fade. Your profile evolves as you do.
• Profile-aware extraction: After the first run, synapptic sends your existing profile to the LLM so it skips known patterns and focuses on what's genuinely new. Less redundancy, lower cost.
• Guards from day one: When the AI makes a concrete mistake, the corresponding guard enters your profile immediately - no need to wait for it to happen twice.

Custom extraction patterns

synapptic ships with a default extraction pattern, but you can create your own - different prompts for different use