Skip to content
Skills Library
AI & agents · Automation

user-preferences

/user-preferences

Use to RECORD or APPLY durable, cross-project user preferences — how the user likes their code, presentations, emails, and language tone — so the agent moulds to them over time ('oh, he prefers pytest / em-dashes / short emails'). Capture is EXPLICIT only: record a preference when the user states one ('remember I prefer X', 'always do Y', 'I don't like Z'); NEVER auto-infer. Before domain work (writing/refactoring code, building a deck, drafting an email, choosing tone/voice) LOAD the matching profile and honor it. Also documents the two-tier file-memory model (global + per-project). Trigger o

Licence
MIT
Last repository change
31.07.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
7
Scripts
2
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 31.07.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 2 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/prefs.py, tests/test_prefs.py

What it does and when to use it

Use to RECORD or APPLY durable, cross-project user preferences — how the user likes their code, presentations, emails, and language tone — so the agent moulds to them over time ('oh, he prefers pytest / em-dashes / short emails'). Capture is EXPLICIT only: record a preference when the user states one ('remember I prefer X', 'always do Y', 'I don't like Z'); NEVER auto-infer. Before domain work (writing/refactoring code, building a deck, drafting an email, choosing tone/voice) LOAD the matching profile and honor it. Also documents the two-tier file-memory model (global + per-project). Trigger o

Triggers from the description

oh, he prefers pytest / em-dashes / short emailsremember I prefer Xalways do YI don
Original author description

Use to RECORD or APPLY durable, cross-project user preferences — how the user likes their code, presentations, emails, and language tone — so the agent moulds to them over time ('oh, he prefers pytest / em-dashes / short emails'). Capture is EXPLICIT only: record a preference when the user states one ('remember I prefer X', 'always do Y', 'I don't like Z'); NEVER auto-infer. Before domain work (writing/refactoring code, building a deck, drafting an email, choosing tone/voice) LOAD the matching profile and honor it. Also documents the two-tier file-memory model (global + per-project). Trigger o

How it works

  1. Two-tier memory model (the foundation)
  2. Preference profiles
  3. HARD-RULE — capture is EXPLICIT only
  4. APPLY — load before domain work
  5. Session-start awareness
  6. Install / seed
  7. Composition
Original SKILL.md headings · 81 lines, 583 words
SKILL.md preview
---
name: user-preferences
description: "Use to RECORD or APPLY durable, cross-project user preferences — how the user likes their code, presentations, emails, and language tone — so the agent moulds to them over time ('oh, he prefers pytest / em-dashes / short emails'). Capture is EXPLICIT only: record a preference when the user states one ('remember I prefer X', 'always do Y', 'I don't like Z'); NEVER auto-infer. Before domain work (writing/refactoring code, building a deck, drafting an email, choosing tone/voice) LOAD the matching profile and honor it. Also documents the two-tier file-memory model (global + per-project). Trigger on: 'remember I prefer', 'always do X', 'I like/don't like', 'from now on', 'set my preference', 'what are my preferences', 'apply my coding/email/presentation/tone style'."
---

# user-preferences — durable, learnable user preferences (explicit capture)

The system that lets this agentic setup **mould to the end user** — it records what the
user explicitly prefers and re-applies it across sessions and projects, so outputs drift
toward "what the user would have done." Pure-stdlib, file-based, no inference.

## Two-tier memory model (the foundation)

| Tier | Path | Holds | Loaded |
|---|---|---|---|
| **Global** | `~/.claude/memory/` (`MEMORY.md` + files) | who the user is, cross-project feedback, **preference profiles** | **every** session (in-project or outside) |
| **Project** | `~/.claude/projects/<slug>/memory/` | project-specific facts/decisions | only when working **inside** that project |

Precedence: project memory **layers on top of** global; on a direct conflict the project
fact wins for that project, and the conflict is surfaced (never silently merged). User
preferences are GLOBAL by design (they describe the person, not the project).

## Preference profiles

One markdown profile per domain under `~/.claude/memory/preferences/`:
`coding.md`, `presentations.md`, `email.md`, `tone.md` (custom domains allowed). Each has
a flat `key: value` frontmatter (the structured prefs loaded as constraints) + a dated
free-form body (nuance + history). Managed ONLY through `scripts/prefs.py` (stdlib):

```bash
python3 scripts/prefs.py list                              # domains + key counts
python3 scripts/prefs.py show  <domain>                    # full profile
python3 scripts/prefs.py load  <domain>                    # prefs as constraints (before domain work)
python3 scripts/prefs.py set   <domain> <key> <value...>   # record/update a structured pref
python3 scripts/prefs.py note  <domain> <free text...>     # record a nuance that has no clean key
```

## HARD-RULE — capture is EXPLICIT only

Record a preference ONLY when the user states one — "remember I prefer X", "always do Y",
"I don't like Z", "from now on …". **Never infer a durable preference from a single
choice or correction silently.** (If you notice a likely pattern you may *ask* "want me to
remember that?", but you do not write it unless they say yes.) This keeps the store
trustworthy — every entry is something the user actually asked for.

When recording: pick the domain (coding/presentations/email/tone/custom), map it to a
structured `set <domain> <key> <value>` when it fits a clean key, else `note`. Confirm
back ("recorded: coding.test_framework = pytest").

## APPLY — load before domain work

Before producing domain output, load the matching profile and treat it as constraints:

| Doing… | Load |
|---|---|
| writing / refactoring / reviewing code | `prefs.py load coding` |
| building slides / a deck | `prefs.py load presentations` |
| drafting an email | `prefs.py load email` |
| any user-facing prose (always) | `prefs.py load tone` |

Honor the loaded prefs unless the user's current request overrides them (the live request
always wins). This is also wired as a directive in CLAUDE.md so it applies even when this
SKILL.md is not in front of you.

## Session-start awareness

The `_meta/memory_primer.py` SessionStart hook prints, every session, which memory tiers
loaded (global always; project when in-project) and the live `N skills · M agents · K
gates` so the agent starts **fully aware** of both its capabilities and the user's
recorded preferences.

## Install / seed

`installer/bootstrap-environment.py` seeds `~/.claude/memory/preferences/` from this
skill's `profiles/` (idempotent — never overwrites a populated profile) and wires the
memory_primer hook, so a fresh machine starts with the schema + the standing behavior.

## Composition

- `presentation-builder` / `content-writer` / `career-application-writer` / email work →
  load the relevant profile first.
- `human-voice-writing` → reads the `tone` profile.
- The global `MEMORY.md` index links to user/feedback/reference memories; preference
  profiles are the structured subset of the `user` memory type.
Files in this package (7)
  • SKILL.md 5 KB
  • profiles/coding.md 1 KB
  • profiles/email.md 1 KB
  • profiles/presentations.md 1 KB
  • profiles/tone.md 1 KB
  • scripts/prefs.py 6 KB
  • tests/test_prefs.py 3 KB

Versions

RepositoryScoreLicence
This page · joogy06/agent-foundry100MIT
x-school-academy/skill-pilot100MIT

Database snapshot: 13.11.2026 · package version 66ed73d88b87 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90personal-memory
    Use this skill whenever how the user personally likes to work is relevant — their response style, formatting preferences, editor and tooling choices, workflow habits, or anything they have told you about themselves. Also use it the moment you learn a durable preference, when the…
  • 90working-style
    Working style - the user's personal profile of preferences. Use at the start of every task (read it), whenever the user corrects, rejects, approves or states a preference (record it), and when they ask to learn, update or show their style.
  • 100self-improvement
    Stores user corrections and preferences as learnings to improve future responses. Use when the user corrects a mistake, states a preference, or says 'remember that', 'from now on', or 'I prefer'.
  • 100memory-first
    Persist durable user preferences, validated approaches, project conventions, and reference pointers via the `memory` tool. Save when the user corrects your approach, expresses a preference, validates a non-obvious decision, or references an external system. Do NOT save code…
  • 100memory
    Prefer MEHO memory for operator preferences and durable notes in a MEHO-wired repo. Use when recording a behavioural preference, an operator note, or team-shared knowledge that should follow the operator or tenant across machines — reach for `add_to_memory` / `meho remember` /…
  • 90global-audit
    Audits and optimizes the five global Claude layers (User Preferences, Styles, Global Memory, Skills, MCP Connectors) using the Global Layer Scorecard (six dimensions, anchored 1-5 rubrics). Detects eight cross-layer failure modes and produces evolutionary recommendations…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.