Dear User

by bleedmode

367 downloads

Not rated

GitHub

About

Tells you how you and your Claude agent actually work together. Reads your CLAUDE.md, hooks, skills, memory, and scheduled tasks — then writes you a letter. Three core tools: collab (collaboration scoring + lint), security (secrets scan, prompt-injection surfaces, rule conflicts)

Details

Author: bleedmode
Downloads: 367
Categories: AI, Communication, Security, Developer Tools

- Full collaboration report with persona detection and 0–100 score
- Secret scanner covering 12 categories (API keys, tokens, etc.)
- Health check for orphan tasks, overlapping skills, dead hooks
- Semantic conflict detection for contradictory agent rules
- Shareable Wrapped stats card (anonymized, opt-in upload)
- Feedback loop that tracks which recommendations you implemented

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Dear User

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "dear user": {
            "dearuser": {
                "command": "npx",
                "args": [
                    "-y",
                    "@poisedhq/dearuser-mcp@latest"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "dear user": {
            "dearuser": {
                "command": "npx",
                "args": [
                    "-y",
                    "@poisedhq/dearuser-mcp@latest"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "dear user": {
            "dearuser": {
                "command": "npx",
                "args": [
                    "-y",
                    "@poisedhq/dearuser-mcp@latest"
                ]
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "dear user": {
            "dearuser": {
                "command": "npx",
                "args": [
                    "-y",
                    "@poisedhq/dearuser-mcp@latest"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "dear user": {
            "dearuser": {
                "command": "npx",
                "args": [
                    "-y",
                    "@poisedhq/dearuser-mcp@latest"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "dear user": {
            "dearuser": {
                "command": "npx",
                "args": [
                    "-y",
                    "@poisedhq/dearuser-mcp@latest"
                ]
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "dear user": {
            "dearuser": {
                "command": "npx",
                "args": [
                    "-y",
                    "@poisedhq/dearuser-mcp@latest"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "dear user": {
            "dearuser": {
                "command": "npx",
                "args": [
                    "-y",
                    "@poisedhq/dearuser-mcp@latest"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "dear user": {
            "dearuser": {
                "command": "npx",
                "args": [
                    "-y",
                    "@poisedhq/dearuser-mcp@latest"
                ]
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "dear user": {
            "dearuser": {
                "command": "npx",
                "args": [
                    "-y",
                    "@poisedhq/dearuser-mcp@latest"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "dear user": {
            "dearuser": {
                "command": "npx",
                "args": [
                    "-y",
                    "@poisedhq/dearuser-mcp@latest"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "dear user": {
            "dearuser": {
                "command": "npx",
                "args": [
                    "-y",
                    "@poisedhq/dearuser-mcp@latest"
                ]
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "dear user": {
            "dearuser": {
                "command": "npx",
                "args": [
                    "-y",
                    "@poisedhq/dearuser-mcp@latest"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "dear user": {
            "dearuser": {
                "command": "npx",
                "args": [
                    "-y",
                    "@poisedhq/dearuser-mcp@latest"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "dear user": {
            "dearuser": {
                "command": "npx",
                "args": [
                    "-y",
                    "@poisedhq/dearuser-mcp@latest"
                ]
            }
        }
    }
}

From the repository

Install with one command (claude mcp add dearuser -- npx @poisedhq/dearuser-mcp), then ask your agent "Analyze my collaboration with Claude" or use slash commands like /dearuser-collab. After installation, start with a baseline scan, then a security sweep, and optionally share a Wrapped card.

`collab`

Analyze your human-agent collaboration. Scans your agent contract (CLAUDE.md or AGENTS.md), memory files, hooks, skills, and more to produce a collaboration report with persona detection, scoring, friction analysis, and recommendations. Returns a pre-formatted markdown report. Use the format parameter to control detail level: - "text" (default): concise, plain-language report designed for non-technical users - "detailed": full technical report with stats, session patterns, injection findings, feedback loop - "json": raw structured data for programmatic use Everything runs locally — no data leaves the machine, no API keys needed, files are only read (never modified). IMPORTANT — Presenting results: The user cannot see raw tool results. You MUST output the full report as your response text — do NOT summarize, shorten, or add commentary around it. The report is pre-formatted for direct display. After showing the report, offer to implement any recommendation marked "Actionable". Tool recommendations with a "whoActs" line indicate whether you (the agent) can install it or the user needs to act — present accordingly. Example prompts that should trigger this tool: - "Analyze my collaboration with Claude" - "How good is my Claude setup?" - "What should I improve in my CLAUDE.md or AGENTS.md?" - "Score my agent configuration"

`health`

Check the health of your AI stack. Returns a 0-100 system-sundhed score with category breakdown, plus findings ranked by severity. Complement to collab: where collab scores how well you and the agent communicate, health scores whether your skills, hooks, scheduled tasks, and MCP servers are still hanging together or have started drifting apart. Detects: - **Orphan scheduled jobs** — task produces output nothing reads - **Stale schedules** — jobs that stopped firing silently despite being enabled - **Expected jobs missing** — jobs declared in ~/.dearuser/expected-jobs.json that aren't registered - **Overlap** — skills/tasks/commands with similar purpose or same output path - **Missing closure** — non-scheduled producers with no downstream reader - **Substrate mismatch** — memory files that look like databases in disguise - **Unregistered MCP tools** — skills calling tools whose server isn't registered - **Unbacked-up substrate** — active ~/.claude/ files outside version control - **Reconciliation gap** — findings open in the ledger for 14+ days (closed-loop failure) What this tool does NOT do: - Does NOT fix problems — it identifies them for you to decide - Does NOT delete or modify any files, skills, or hooks - Does NOT contact external services — pure local filesystem analysis IMPORTANT — Presenting results: The user cannot see raw tool results. You MUST output the full report as your response text — do NOT summarize, shorten, or add commentary around it. The report is pre-formatted for direct display. Show the score and ceiling prominently. Lead with critical findings, then recommended, then nice-to-have. Each finding has a stable id users can reference to dismiss. Heuristic-based detection has some false positives — frame findings as "likely" not "definitely". Example prompts that should trigger this tool: - "Check my system's health" - "Are any of my scheduled tasks orphaned?" - "Run dearuser health" - "Is my agent substrate well-structured?"

`history`

Retrieve past Dear User reports without re-running the scan. Reads from local SQLite (~/.dearuser/dearuser.db) — no network, no fresh scan. Use when the user wants to see their latest score, how scores have changed over time, or what got better/worse since the last run. A fresh scan takes ~30s; this returns instantly. Call `collab`/`health`/`security` instead if the user explicitly asks for a new scan. Three formats: - **"summary"** (default): latest stored report per scope. Fast, no re-scan. Use when the user asks what the previous/overnight report said. - **"trend"**: score sparkline over time per scope, with delta from oldest to newest. Use for "is it getting better?" questions. - **"regression"**: delta vs prior run — score change + new/resolved findings by stable ID. Use for "what changed?" / "what's new?" questions. Scope narrows to one area: "collab", "health", "security", or "all" (default). Pass `run_id` to fetch a specific historical report by its ID (printed at the bottom of every Dear User report). What this tool does NOT do: - Does NOT run any new scans — pure read of stored reports - Does NOT delete or modify stored history - Does NOT contact any external service — everything stays on your machine IMPORTANT — Presenting results: The user cannot see raw tool results. You MUST output the full report as your response text — do NOT summarize or add commentary. Output is pre-formatted markdown with a "What to do next" section. Example prompts that should trigger this tool: - "Vis seneste rapport" - "Show me the latest collab score" - "Er sikkerheden blevet bedre?" - "Hvad fandt nattens scan?" - "What changed since last run?" - "Vis trend"

`onboard`

Conversational setup. Walks the user through 5 steps (intro → goals → stack+pains → substrate → plan) and produces a tailored setup plan — tailored agent-contract template (CLAUDE.md or AGENTS.md), skill recommendations, hook recommendations, and next 3 steps. How to use (for the agent): 1. First call: no arguments. The tool returns an intro question + nextStep. 2. Present the question to the user and collect their answer. 3. Call again with step=<nextStep from previous>, answer=<user answer>, state=<state from previous>. 4. Continue until done=true, then show the plan. IMPORTANT — Presenting results: The user cannot see raw tool results. You MUST output each step's response text as your response — do NOT summarize, rephrase, or wrap it in your own words. The questions and final plan are pre-formatted for direct display. Just show what the tool returns, then collect the user's answer for the next step. IMPORTANT: The `state` parameter is opaque. Pass it back verbatim. Do not parse or modify it. What this tool does NOT do: - Does NOT write files automatically — it produces a plan for the user/agent to apply - Does NOT require prior Claude Code experience — designed for first-time users - Does NOT collect or transmit any answers — state is a local opaque blob passed between calls Good for: new users, non-technical professionals, anyone setting up Claude Code for the first time, or someone revisiting goals after a while. Example prompts that should trigger this tool: - "Set up Dear User for me" - "I'm new to Claude Code, help me configure it" - "Onboard me" - "Help me create a CLAUDE.md" - "Help me create an AGENTS.md"

`security`

Security audit of your AI setup. Scans for: - **Leaked secrets** — API keys, tokens, credentials in CLAUDE.md / AGENTS.md, memory, skills, or settings - **Prompt-injection surfaces** — hooks/skills that pass user input to shell unsafely - **Rule conflicts** — your agent contract says one thing but a hook/skill does another (e.g., "never force-push" but a hook runs `git push --force`) Presents findings sorted by severity (critical → recommended → nice-to-have). Secrets and rule conflicts are the highest-trust signals because false positives are rare; injection findings are pattern-based and may warrant manual review. What this tool does NOT do: - Does NOT access your passwords, keychains, or browser saved credentials - Does NOT send findings to any external service — everything stays local - Does NOT auto-rotate or revoke credentials — it reports, you act - Does NOT scan source code repositories — only your agent config files (~/.claude/, memory, skills, hooks) IMPORTANT — Presenting results: The user cannot see raw tool results. You MUST output the full report as your response text — do NOT summarize, shorten, or add commentary around it. The report is pre-formatted for direct display. Lead with secrets (rotate any found credentials immediately). Be precise about rule conflicts — show the rule AND the conflicting action. Don't minimize: "no findings" is a REAL signal of clean setup, not evidence of a broken scanner. Example prompts that should trigger this tool: - "Scan my Claude setup for security issues" - "Are there any leaked API keys in my config?" - "Check my hooks for prompt injection risks" - "Security audit of my agent setup"

`wrapped`

Generate your Dear User — shareable stats about your human-agent collaboration in a fun, Spotify Wrapped-style format. What this tool does NOT do: - Does NOT share anything automatically — it generates text you can copy/paste if you choose - Does NOT access external accounts or profiles - Does NOT store or upload the generated stats anywhere IMPORTANT — Presenting results: The user cannot see raw tool results. You MUST output the full report as your response text — do NOT summarize, shorten, or add commentary around it. The report is pre-formatted for direct display. Example prompts that should trigger this tool: - "Give me my Dear User Wrapped" - "Show my collaboration stats" - "Generate shareable stats about my Claude usage"

`implement_recommendation`

Apply a Dear User recommendation to the user's setup — automatically if safe, or by returning the exact command/instruction for the agent to run. After a collab/health/security report runs, the result text contains a "Three things to fix" menu with up to 3 recommendation_ids plus "Take all of them" and "Skip for now" options. Present those options to the user via AskUserQuestion (or as a numbered list if AskUserQuestion isn't available). When the user picks an item: call this tool with that recommendation_id. When the user picks "Take all": call this tool once per id, in order. When the user picks "Skip" or dismisses an item: call mcp__dearuser__dismiss_recommendation instead. Behavior by action_type: - **claude_md_append** — appends the markdown rule to ~/.claude/CLAUDE.md (with timestamped backup). Idempotent. - **settings_merge** — merges a JSON snippet into ~/.claude/settings.json (with backup, arrays deduped). Idempotent. - **shell_exec** — returns the shell command for YOU (the agent) to run via the Bash tool. Do NOT paraphrase; run it verbatim. - **manual** — returns instructions that need human judgment; present them to the user. After a successful implementation, the recommendation's status is marked "implemented" so Dear User won't suggest it again. IMPORTANT: Present the ImplementResult back to the user in plain Danish — confirm what changed, show any backup paths, and if there's a `command` field, run it via Bash and report the result. If `ok:false`, tell the user why and suggest they try again or do it manually.

`dismiss_recommendation`

Mark a Dear User recommendation as dismissed so it won't be suggested again. Call this when the user picks "drop"/"ikke for mig"/"skip" for a specific recommendation from the action menu. Use recommendation_id from the latest report's menu. For security/health findings, the dismissal propagates to the underlying finding in the ledger so future scans won't re-surface it (unless dismiss_expires_at elapses).

`feedback`

Send a short note to the Dear User team — a bug, a request, a "this score feels wrong", or anything you want the founder to read. Zero friction: one tool call and you're done. Behavior: - POSTs your message to the Dear User feedback inbox (Supabase) over HTTPS. - Respects Dear User's local-first guarantee — this is the one place data leaves the machine. - Email is only attached when opt_in_followup=true AND an email is provided. - No retries — if the network fails, you get a clear message and the payload is logged locally. - For public questions/ideas, point to GitHub Discussions: https://github.com/bleedmode/dearuser/discussions What this tool does NOT do: - Does NOT send anything automatically — the agent must have called this tool with an explicit message from the user. - Does NOT read past feedback — it is write-only from this side. The founder reads the inbox directly in Supabase. - Does NOT upload anything about your setup, files, or reports. Only what you put in the message. Context options: "collab" | "security" | "health" | "wrapped" | "general" — pick the tool the user just ran so the founder can slice the inbox. Length guidance: keep the confirmation you show the user short. If the user typed a one-liner, the reply can be one line. Example prompts that should trigger this tool: - "This score feels wrong — send feedback: the collab score is too low for a brand new project" - "Send feedback to Dear User: loving it, but the health findings could be shorter" - "Tell them I want Windows support" - "Send a bug report: health tool crashed on me"

`help`

Show Dear User's capabilities to the user. Call this whenever the user asks "what can Dear User do?", "hvad kan DearUser?", "show me the options", "help", or seems uncertain about which tool fits their need. Also call proactively the first time a user mentions Dear User if they haven't used it before. What this tool does NOT do: - Does NOT run any analysis — it only describes what Dear User can do - Does NOT access or read any user files When presenting: return the text verbatim. Do NOT summarize or re-wrap — the formatting is designed for direct chat display.

`share_report`

Generate a public shareable link for your Dear User Wrapped card. Uploads an anonymized copy to dearuser.ai and returns a URL you can paste anywhere (X, LinkedIn, Slack). Only Wrapped reports are shareable. Collab/health/security reports stay local. Privacy contract: - Absolute filesystem paths are collapsed to basenames. - Email addresses are stripped. - Anything matching our secret-scanner patterns (API keys, tokens, JWTs, private keys) is redacted before upload. - The user's local ~/.dearuser/ database is NOT modified. Works out of the box — uploads through the public dearuser.ai Supabase endpoint with an RLS-protected anon key. Forks/staging deployments can override with DEARUSER_SUPABASE_URL + DEARUSER_SUPABASE_ANON_KEY. IMPORTANT — Presenting results: Show the returned URL prominently and tell the user it's public. Do NOT auto-paste it anywhere on their behalf. Example prompts that should trigger this tool: - "Share my Wrapped" - "Lav et delbart link til min Wrapped"

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "dear user": {
            "dearuser": {
                "command": "npx",
                "args": [
                    "-y",
                    "@poisedhq/dearuser-mcp@latest"
                ]
            }
        }
    }
}

McpServers

{
    "dearuser": {
        "command": "npx",
        "args": [
            "-y",
            "@poisedhq/dearuser-mcp@latest"
        ]
    }
}

Dear User

Your AI agent works for you — but how well do you work together? Dear User is an open-source tool that audits your Claude Code setup and tells you exactly what to fix. It scores your collaboration, finds leaked secrets and config conflicts, and checks system health — all locally, nothing uploaded unless you explicitly share your Wrapped card. > claude mcp add dearuser -- npx @poisedhq/dearuser-mcp > > Then ask Claude: "Analyze my collaboration with Claude" Landing: dearuser.ai · Feedback: use the feedback tool in Claude, or open an issue ---

What it does

Dear User is an MCP server (Model Context Protocol — the plugin system Claude Code and Claude Desktop use). Once installed, it shows up as a set of tools your agent can call. No GUI, no sign-up, no cloud account. Three local reports, one shareable Wrapped card, one feedback channel: | Tool | What it does | Example prompt | |------|--------------|----------------| | collab | Full collaboration report — persona, 0-100 score, friction patterns, specific recommendations | "How good is my Claude setup?" | | security | Leaked secrets, prompt-injection surfaces, rule conflicts in your agent contract (CLAUDE.md or AGENTS.md) | "Check my config for leaked API keys" | | health | Structural coherence — orphan scheduled tasks, overlapping skills, dead hooks | "Is anything broken in my setup?" | | wrapped | Spotify-style shareable stats card — scores + counts + persona. Opt-in public URL via share_report. | "Give me my Dear User Wrapped" | | feedback | Send a note to the Dear User inbox | "Send feedback: the health report could be shorter" | Plus helpers: onboard (7-step guided setup), history (trend without re-scanning), help (menu), implement_recommendation, dismiss_recommendation, share_report (Wrapped-only upload).

Launch highlights

- Shareable Wrapped — run wrapped, then share_report to get a dearuser.ai/r/<token> URL for your stats card. Anonymized before upload (paths collapsed to basenames, emails stripped, secrets redacted). Collab/security/health reports stay local — findings can carry business context that isn't safe to auto-share. - 12-category secret scanner — OpenAI, Anthropic, GitHub, AWS, Stripe, Slack, Google, Supabase, Vercel, private keys, generic env secrets, bearer tokens. Scans CLAUDE.md / AGENTS.md, memory files, skills, hooks. - AGENTS.md native support — first-class input alongside CLAUDE.md. Works out of the box for Cursor, Codex, Aider, Cline, Zed and anyone following the Linux Foundation cross-tool standard. Both files in the same directory? We merge them. - Semantic conflict detection (new) — finds rules that contradict each other even when they don't share keywords. "Commit often" vs. "ask before commit" gets flagged. - Score calibrated against reality — two studies: 988 public Claude Code setups with substrate committed (median 32/100, max 63) and 2,895 standalone CLAUDE.md files (median 18, max 60). The substrate corpus is the apples-to-apples benchmark for live scores. See research/calibration/ for both studies.

Install

One command per client. Full guide: docs/install.md. Claude Code (CLI) ``

bash
claude mcp add dearuser -- npx @poisedhq/dearuser-mcp



Claude Desktop — add to

~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json

 (Windows):

json
{
  "mcpServers": {
    "dearuser": {
      "command": "npx",
      "args": ["@poisedhq/dearuser-mcp"]
    }
  }
}



Cursor, Windsurf, Cline, Zed — see

docs/install.md

.

Optional: install the slash commands (see Commands for the full list) so you can type

/dearuser-collab

 instead of asking in prose:

bash
npx -p @poisedhq/dearuser-mcp dearuser-install-skills



Your first 5 minutes


After installing, restart your client and try these in order:

1. Baseline scan:


   Run Dear User collab on this project


   You'll get a persona (Vibe Coder / Senior Developer / Indie Hacker / Venture Studio / Team Lead), a 0-100 score across 7 categories, and 3-10 concrete recommendations.

2. Security sweep:


   Run Dear User security


   Checks your agent contract (CLAUDE.md or AGENTS.md), memory, skills and hooks for leaked tokens, injection surfaces and rule conflicts.

3. Share the result (optional):


   Share my collab report


   Returns a

dearuser.ai/r/<token>

 link. Anonymized before upload. You choose whether to paste it anywhere.

Example output from

collab


Persona: Indie Hacker (87% confidence)
Score:   73 / 100

Top friction:
  • Quality Standards — no test-before-commit rule in CLAUDE.md
  • Memory Health    — 2 memory files haven't been touched in 90+ days
  • Communication    — no language preference stated (English vs Danish mixing)

Recommendations (3 shown, 5 total):
  1. Add a "Session start protocol" block to CLAUDE.md  (apply with: implement_recommendation)
  2. Rotate the OpenAI key leaked in ~/.claude/memory/api-notes.md
  3. Merge overlapping skills: deploy-check and ship-check share 80% of their rules



Commands


Eight slash commands ship with Dear User. Ask your agent by name, or type the slash command if you installed them with

dearuser-install-skills

.

| Command | What it does |
|---|---|
|

/dearuser-collab

 | Collaboration analysis — persona, 0-100 score across 7 categories, prioritized recommendations. |
|

/dearuser-health

 | System health — orphan jobs, overlap, stale schedules, missing MCP registrations, reconciliation gaps. |
|

/dearuser-security

 | Secret scan, prompt-injection surfaces, and rule conflicts in your agent contract. |
|

/dearuser-wrapped

 | Shareable collaboration stats in a Spotify-Wrapped style card. |
|

/dearuser-onboard

 | Conversational 7-step setup for first-time users. |
|

/dearuser-history

 | Show your last reports, score trend over time, or what changed since the last run — no re-scan. |
|

/dearuser-feedback

 | Send a short note (bug, request, reaction) to the Dear User founders. |
|

/dearuser-help

 | Show what Dear User can do and list every tool. |

Three in-chat actions the agent can call for you:

share_report (upload a Wrapped card to dearuser.ai/r/<token>), implement_recommendation (apply a pending recommendation), dismiss_recommendation

 (mark one irrelevant).

Privacy


Dear User is local-first. Your scans stay on your machine:

- Your agent contract (CLAUDE.md or AGENTS.md), memory, skills, hooks and session metadata are read but never uploaded
- Results are stored in

~/.dearuser/dearuser.db

 (SQLite, WAL mode)
- The optional localhost dashboard reads from that DB — nothing is transmitted
- Dear User reads session metadata only (counts, lengths) — never your actual conversation content
- No API keys required, no sign-up, no telemetry

The only exceptions are things you explicitly trigger:

-

share_report (Wrapped only)

 — your Wrapped card is anonymized (paths collapsed, emails stripped, anything matching our secret patterns redacted) and uploaded to

dearuser.ai so you can share a URL. Your local DB is not modified. You can set an expires_at

 to auto-expire the link. Collab/security/health reports are NOT shareable — findings can carry business context (project names, client names, architecture notes) we don't think should live on a public URL.
-

feedback

 — when you call the feedback tool, your message goes to our Supabase inbox. That's the whole point of the tool. We don't attach your scans or files — only the text you write.

No other tool transmits anything. If

share_report isn't configured with DEARUSER_SUPABASE_URL + DEARUSER_SUPABASE_SERVICE_KEY

, it errors out cleanly and the rest of Dear User keeps working.

Full privacy details:

docs/privacy.md

.

How it works


Your files (CLAUDE.md or AGENTS.md, memory, hooks, skills, sessions)
        │
    Scanner ──► Parser ──► Engines (scoring, secrets, conflicts, health)
        │
 Persona detection → Scoring → Gap analysis → Recommendations
        │
    Feedback loop (tracks which recommendations you implemented)
        │
    ~/.dearuser/dearuser.db  ←  dashboard reads from here



- 5 personas detected from your setup — each gets tailored recommendations
- 7 scoring categories: Role Clarity, Communication, Autonomy Balance, Quality Standards, Memory Health, System Maturity, Coverage
- Feedback loop: Dear User remembers what it recommended. Next run, it checks which ones you implemented and shows the score delta.

Who it's for


- "Vibe coders" — you prompt Claude and ship product, but you're never quite sure if your setup is actually working. Dear User tells you.
- Senior developers — you want a fast audit for leaked secrets, config drift and rule conflicts without wiring up a custom lint pipeline.
- Indie hackers / solo founders — you've accumulated hooks, skills and memory across projects. Dear User surfaces what's orphaned or contradicting itself.
- Team leads — you want a local audit of your team's shared agent setup. Collab, security and health reports stay on your machine; only your personal Wrapped card can be shared publicly.

Repository layout


-

mcp/ — @poisedhq/dearuser-mcp npm package (the MCP server). See mcp/README.md

 for development notes.
-

web/ — dearuser.ai

 landing + share-report pages (Astro).
-

docs/ — install guide, privacy doc, per-platform setup (Supabase/GitHub/Vercel for the optional security

 platform advisors).
-

research/

 — calibration data + architecture notes we're willing to share.

Contributing


See

CONTRIBUTING.md

. Bug reports and small fixes welcome via GitHub issues and PRs.

Links


- dearuser.ai — landing page
- Feedback inbox — or use the

feedback

 MCP tool from inside Claude
- GitHub issues — bugs, feature requests
- Install guide · Privacy · Setup for platform advisors

License


Dear User is MIT-licensed. See

LICENSE`. Open-core commitment: everything in this repo is MIT and stays MIT. If we ever build team or hosted features (agency dashboards, cross-project trend lines, vertical-specific benchmarks), they'll live in separate repos with their own license — never by pulling pieces out of this one.

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

collab

health

history

onboard

security

wrapped

implement_recommendation

dismiss_recommendation

feedback

help

share_report

Claude Desktop / Cursor

McpServers

Dear User

What it does

Launch highlights

Install

Your first 5 minutes

Commands

Privacy

How it works

Who it's for

Repository layout

Contributing

Links

License

Install

More like this

Slack

Context 7

1Panel

🔎 GPT Researcher

Serena

FastMCP v2 🚀

`collab`

`health`

`history`

`onboard`

`security`

`wrapped`

`implement_recommendation`

`dismiss_recommendation`

`feedback`

`help`

`share_report`