Skip to main content

mannerism

Your AI agents write like you, not like ChatGPT.

mannerism learns how you write from text you already have: your prompts, commits, notes and chats. Before an agent writes in your name, it gets your style card, real examples of your writing and the rules you taught it by editing.

Example: the same invoice reply.

Generic agent draft: Hi there, I hope this email finds you well. I just wanted to reach out about the invoice. Please let me know if you have any questions!

With mannerism: the invoice can wait until the 30th, that works on our side

npx skills add vicennial/mannerism

Then tell your agent: learn my voice.

Other ways to install
Harness Command
Claude Code /plugin marketplace add vicennial/mannerism then /plugin install mannerism@mannerism
Codex, Gemini CLI, Cursor, VS Code Copilot, Zed, Amp, Goose, Cline, OpenCode, Warp, Factory Droid, Crush, Windsurf, Continue, Kiro, Claude Desktop, Omnigent mannerism connect <name> --write (Goose, Continue and Omnigent use YAML config, so the command prints the snippet for you to paste)
Skill only npx skills add vicennial/mannerism (17 of 18 harnesses; not Claude Desktop)
Just the CLI uvx mannerism init

mannerism connect with no argument lists every harness it knows and which look installed on this machine. mannerism connect <name> without --write prints the exact snippet first, so you can check it before it touches anything. Config paths, what is tested and known rough edges per harness: docs/harnesses.md.

How it works

  1. It reads what you already wrote. Your prompts to coding agents, your commits, notes and chat exports. Your words only: not the agent's replies, and not other people's messages.
  2. Your agent gets your voice before it writes. A style card of your habits, real examples of your writing and rules learned from your edits. After it drafts, a lint flags the AI tells you never use yourself.
  3. It learns from every edit you make to a draft. Fix a draft, send your version, and mannerism pairs the two. After repeated, consistent edits it turns them into short rules such as "drops greetings". You can see and delete every rule.

Everything is stored on your machine. No account, no API key. Apache-2.0, v0.1.

Setting up

Saying "learn my voice" starts a first pass that takes about a minute and asks you nothing:

  1. mannerism looks for text you already wrote on this machine and shows what it found:

    source        found            messages
    claude_code   140 sessions     1,900
    codex         60 sessions      700
    git           9 repos          850
    
  2. It reads your own words only (your prompts, not the agent's replies; your commits, not your colleagues' or an agent's own co-authored ones) and writes a first style card for each kind of writing it has enough of.

  3. Your agent can then sharpen the cards by reading your writing, and offer a 2-minute blind test: can you tell your real messages from the ones it writes?

After that, each new session syncs what you wrote since the last one. The Claude Code plugin does this with hooks. For Codex, mannerism connect codex --write writes only the MCP entry and the skill, so no Codex Stop or SessionEnd hook is installed today. Details: sessions in throwaway config directories.

What it learns from

Prompts from Claude Code, Codex, OpenCode, Cline, Goose, Aider, Continue, Qwen Code, Kilo Code, Crush and Pi, plus git commit messages, Markdown and Obsidian notes and GitHub comments. Posts and messages from Bluesky, Mastodon, Slack and X, once you configure them. Exports from ChatGPT, Telegram, WhatsApp, X, email (mbox) and iMessage, Wispr Flow dictation, and files or plugins of your own.

The full table (how each source is found, and how well it is tested) is in docs/sources.md, with setup notes for Slack. More: your own sources, host sources (Hermes) and WhatsApp databases. To keep private writing on one host and use only published examples from another, see public-only remote access.

What your agent gets

voice_context("work", task="PR description for the retry fix")

returns:

  • a style card: your habits as rates ("starts lowercase 67% of the time", "rarely uses exclamation marks"),
  • real examples of your writing in that register, chosen to show your range rather than the same topic,
  • rules learned from your edits.

Then voice_lint(draft, "work") checks the draft against your own numbers and a list of common AI tells. It only flags tells that you do not use yourself: if you love em dashes, it won't nag you about em dashes.

Registers: close (one friend), group (group chats), work, formal, agent (prompts to AI agents) and public (posts, READMEs, blogs). Public drafts only ever see your public writing.

Learning from your edits

Every draft your agent lints is remembered (masked, for 45 days). When you later write something that is an edited version of a draft (a commit, a post, a message, or simply pasting your fixed version back into the chat), mannerism pairs them. A register needs at least 5 edited drafts from 3 different conversations before your agent is asked to write rules from them, so one noisy conversation cannot teach a rule. See and delete rules with mannerism rules.

See your voice

mannerism ui

opens a read-only page in your browser: your voice cards (each habit with its count and a real example), the rules learned from your edits, and a few insights. It also has an Is this you? review for groups of stored text. The page listens on 127.0.0.1 only and loads nothing from the network. Details: docs/ui.md.

Control what it reads

If agents, relays or scripts also type into your sessions (a second Claude account, an orchestrator that sends the same status message every time), run mannerism scan before the first sync. It prints what a sync would read, grouped by source, account and project, and stores nothing. Exclusion rules (mannerism exclude add ...) keep text out for good, and text that looks machine-typed is held back from your cards until you say it is yours. See docs/exclusions.md.

Privacy

Your corpus, cards and rules stay in ~/.mannerism (private files, no telemetry). The only network reads are the opt-in public-post sources and gh, each off until you set allow_network = true. The text that voice_context and the setup tasks return goes to your agent, and so to whichever model provider your agent uses, like anything else you show it. Other people's messages are dropped when reading, and emails, phone numbers, card numbers and secrets are masked before anything is stored.

Besides the text, each stored text keeps where it came from: the config directory (your home shown as ~), the working directory's name and path, how the session was driven and a hash of the session id. Exclusion rules and scan use that.

mannerism forget --source whatsapp (or --all) deletes a source and everything derived from it, including packets and rules built from its text, and disables the source so a plain sync cannot quietly bring it back. It cannot recall text your agent has already seen. forget --where --project 'scratch-*' deletes just the texts that match. forget --all also clears the list of config directories the hooks learned. It keeps config.toml (your identity, the switched-off sources, any [[exclude]] rules), the exclusion rules you added with exclude add and your "it's me" decisions; remove those with exclude rm ID or by editing the file.

Does it work?

The approach comes from a private prototype the author used for two weeks. On 94 held-out messages, a judge model mistook plain Claude drafts for the real message 19% of the time; with a style card and examples, 43%. In a blind test on his own messages, the author still spotted his real message 17 times out of 20, but preferred the voice-matched draft over plain Claude 13 to 4. So: closer, not identical. Run the blind test on yourself.

How is this different from…

mannerism AI-tell rewriters (e.g. humanizer) A style prompt Fine-tuning
Learns your voice yes, from your own text no, removes generic AI tells only what you describe yes
Different voices for friends, work, public yes (registers) no by hand one model per voice
Keeps learning from your edits yes no no retrain
Setup one command, no data prep none write it yourself dataset + training
Stored on your machine yes yes yes depends

They combine well: mannerism's lint already includes common AI tells (credits below).

Commands

mannerism init                     find sources, read them, write first cards
mannerism status                   what it knows and what's pending
mannerism sync [--quick]           read new text (hooks do this for you)
mannerism context REGISTER         card + rules + examples
mannerism lint [--register R] FILE check a draft
mannerism rules [rm ID]            learned rules
mannerism ui [--port N] [--no-open]  voice cards, insights and the "Is this you?" review in your browser
mannerism sources [add|enable|disable]
mannerism scan [--json] [--samples N]  what a sync would read, grouped; stores nothing
mannerism exclude add|list|rm      never store matching text (--source --account --project --kind --text --group [--force])
mannerism review [keep GROUP|rescan]  texts held back as machine-typed
mannerism forget --source S | --drafts | --all | --where <same flags as exclude add>
mannerism mcp                      run the MCP server (stdio)

Design notes and internals: docs/design.md.

Credits

The AI-tell list adapts entries from blader/humanizer (MIT) and sam-paech/slop-forensics (MIT); see NOTICE. Wikipedia's "Signs of AI writing" was used as a checklist. Example selection follows research showing that diverse examples from the same register beat topic-matched ones for style imitation (arXiv 2509.14543); edit-learned rules follow CIPHER (arXiv 2404.15269).

License

Apache-2.0

Metadata

Release files for mannerism 0.1.1

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for mannerism 0.1.1
File Size Uploaded Provenance Actions
mannerism-0.1.1.tar.gz 613.3 kB Without provenance Details for mannerism-0.1.1.tar.gz

Built distribution (wheel)

Table of built distributions (wheels) for mannerism 0.1.1
File Interpreter ABI Platform Actions
mannerism-0.1.1-py3-none-any.whl Python 3 none any Details for mannerism-0.1.1-py3-none-any.whl

Total release size: 986.7 kB

Release files / mannerism-0.1.1.tar.gz

Download URL mannerism-0.1.1.tar.gz
Size 613.3 kB
Tags Source
SHA-256 checksum
How to use checksums
bcfb798ede1c2ff59286d53f2439dbe11e41caaed713c50463031740ff863743
BLAKE2b-256 checksum
How to use checksums
2209f935fde493dfb393f14262be5861c0b3bd2a38e22916db9253df3e2f9a18
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via uv/0.11.28 {"installer":{"name":"uv","version":"0.11.28","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"26.04","id":"resolute","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":null}

Release files / mannerism-0.1.1-py3-none-any.whl

Download URL mannerism-0.1.1-py3-none-any.whl
Size 373.4 kB
Tags Python 3
SHA-256 checksum
How to use checksums
3d306fdadd0b222526c6b2a6387e886b85806d4aa6d8fd1be23d4bd6b912e745
BLAKE2b-256 checksum
How to use checksums
ea8c20ce02382cf66bdd068c38fb1d6b2989f68801477c48f3170d349d4ff23d
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via uv/0.11.28 {"installer":{"name":"uv","version":"0.11.28","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"26.04","id":"resolute","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":null}

Security for mannerism 0.1.1

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Release history Release notifications | RSS feed

This release

0.1.1 This release

2 release files No provenance

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page