auto-memory-rules

Original：🇨🇳 Chinese

Translated

6 scripts

Trigger Scenarios: (1) Explicit memory requests – remember, record, don't forget, pay attention next time, form rules, generate summaries/record documents; (2) Correction and modification – note, incorrect, wrong, it should be, change to, replace with, don't, also need, missing; (3) Preference expression – I prefer, in the future, it's better, suggest, my habit, I usually; (4) Global specifications – unified, all, every, any, each, every time, all, uniformly; (5) Conversation end settlement – when the conversation ends naturally or the topic switches. Convert users' corrections, preferences and rules into structured memory files to improve the output quality of subsequent conversations.

2installs

Sourcehestonhsl/auto-memory-rules

Added on2026-03-24

NPX Install

npx skill4agent add hestonhsl/auto-memory-rules auto-memory-rules

SKILL.md Content (Chinese)

View Translation Comparison →

Auto-Memory-Rules Core Execution Guidelines

Highest Priority

User's real-time requirements > Historical memory — When there is a conflict, unconditionally execute the user's requirements, and ask whether to overwrite the old memory when the conversation ends.

Trigger and Handling

Intent Type	Trigger Signals	Priority	Handling Strategy
Explicit Correction	"incorrect", "wrong", "it should be..."	🔴 High	Immediate reflection + Record
Modification Request	"change to...", "replace with...", "don't..."	🔴 High	Immediate reflection + Record
Preference Expression	"I prefer...", "it's better...", "suggest..."	🟡 Medium	Record after reflection
Method Guidance	"use...command", "go to...query"	🟡 Medium	Record after reflection
Interaction Optimization	Adjustments to answer methods, formats, styles	🟡 Medium	Record after reflection
Global Specification	unified, all, all of, all + verb, any, each, every time, all, uniformly	🟡 Medium	Record after reflection
One-time Modification	"handle specially here", "temporarily..."	⚪ Low	Do not record

Even if the user doesn't explicitly say "remember", when the same issue is corrected more than 2 times, proactively ask whether to record it as a rule:

💡 Detected recordable memory: [Brief description]
Do you want to record it to the memory system? I will automatically apply it next time. [Y/n]

Self-Reflection Process

Three layers of reflection are required before creating memory:

Surface Level: What did the user say?
Deep Level: Why did they say that? What was insufficient in my response?
Principle Level: What is the underlying general rule? Can it be generalized to similar scenarios?

Memory Quality Standards

Core Question: Will this rule reduce the user's need for modification requests next time?

Should record: User's explicit preferences, repeated modification patterns (2+ times), general principles reusable across projects, code style/architecture/interaction preferences

Should not record: One-time special handling, project-specific business logic, temporary solutions, pure concept explanations

Quality Check:

De具体化 — Remove file paths, line numbers, specific variable names
High Executability — AI can execute immediately after reading
Cross-task Universality — Remains effective in other similar scenarios
Anti-attenuation — Clear rule logic that won't become invalid over time
Record "why", not just "what to do"

Conflict Handling:

Rule Evolution — If the user explicitly overturns old habits, ask before overwriting the old rule
Scenario Branching — If two rules are valid in different scenarios, merge them into one rule and describe their respective trigger scenarios separately

Task Lifecycle

1. Conversation Start

Check the
```
memory/
```
directory under the skill directory (e.g.:
```
.agents/skills/auto-memory-rules/memory/
```
), initialize it if it doesn't exist
Search for relevant memories based on the user's request and load them into the context

2. Conversation Execution

Reflect → Extract principles → Create memory files in the
```
memory/
```
directory under the skill directory
Apply immediately in the current task
Inform the user: "I have recorded this memory and will apply it automatically next time"

3. Rule Update (Settlement)

Execution Steps:

bash

# Step 1: Update index and checklist
# If hooks are installed (see installation instructions below), it will be triggered automatically when writing memory files, no manual execution needed
# Run manually if hooks are not installed:
bash scripts/generate-memory-artifacts.sh

# Step 2: Update platform rules (automatically detect and update all platforms in the current project)
bash scripts/generate-rules.sh

Output settlement report:

✅ Memory system settlement completed
- New memories added: N
- Updated index: memory/index.md
- Updated checklist: memory/CHECKLIST.md
- Updated platform rules: <Automatically detected platforms>

Installation and Compatible Platforms

Kiro: Skill directory

.kiro/skills/auto-memory-rules/

, use

generate-integration-rules.sh

+

generate-rules.sh

Antigravity: Skill directory

.agents/skills/auto-memory-rules/

, use

generate-integration-rules.sh

+

generate-rules.sh

Cursor: Skill directory

.cursor/skills/auto-memory-rules/

(compatible with

.agents/skills/

), rules output to

.cursor/rules/

Windsurf: Skill directory

.windsurf/skills/auto-memory-rules/

, use

generate-rules.sh windsurf

to generate rule files

Claude Code: Skill directory
```
.claude/skills/auto-memory-rules/
```
, rules output to
```
.claude/rules/
```
; optional hook installation for automatic memory index update (can also execute scripts manually if not installed)

To enable automatic index update in Claude Code, run the following in the root directory of the project using this skill:

bash

bash <path-to-skill>/auto-memory-rules/scripts/setup-hooks.sh

After installation, each time a

.md

file is written to the

memory/

directory under the skill directory,

generate-memory-artifacts.sh

will be triggered automatically; for other platforms, you can run this script manually to complete settlement.

Standard Category

Category	Applicable Scenarios
`api`	API calls, interface definitions, HTTP requests, URL specifications
`types`	TypeScript types, interfaces, generics
`component`	React components, JSX, Props design
`hook`	Custom Hooks, useXxx encapsulation
`state`	State design, data flow, state recovery
`backend`	Backend services, business layering, controller/service/repository design
`database`	Database modeling, SQL, indexes, transactions, migrations
`infra`	Deployment, CI/CD, containers, environment variables, monitoring and alerts
`testing`	Unit testing, integration testing, E2E, testing strategies
`security`	Authentication and authorization, permission models, input validation, security baselines
`pattern`	Design patterns, architecture patterns, code organization
`convention`	Naming, formatting, code style, comments
`quality`	Maintainability, performance optimization, best practices
`workflow`	Development processes, debugging methods, troubleshooting
`general`	Cross-domain general rules, preferences not suitable for the above categories

Choose the most core one when there are conflicts in multiple aspects.

Memory File Template

File name:

YYYY-MM-DD-{category}-{brief-description}.md

markdown

---
category: [Select only one from the standard list]
priority: [high|medium|low]
tags: [keyword1, keyword2]
description: [One-sentence description]
---

# [Memory Topic]

## Reflection Record
**What the user said**: [Original expression]
**Why they said it**: [Analysis]
**Extracted principle**: [General principle]

## Core Principle
[One-sentence summary]

## Specific Requirements
- [Executable instructions]

## Checkpoints
- [ ] [Statement: Describe what should be done]

Note: Use declarative sentences for checkpoints, not questions or error descriptions
✅ Good: Hooks are not allowed to expose internal setters
❌ Bad: Does the hook expose the setter?
❌ Bad: The hook exposes the setter

## Examples
✅ [Good example]
❌ [Example to avoid]

## Related Memories
- [Related memory file name](related-memory-file-name.md)

auto-memory-rules

NPX Install

Tags

SKILL.md Content (Chinese)

Auto-Memory-Rules Core Execution Guidelines

Highest Priority

Trigger and Handling

Self-Reflection Process

Memory Quality Standards

Task Lifecycle

1. Conversation Start

2. Conversation Execution

3. Rule Update (Settlement)

Installation and Compatible Platforms

Standard Category

Memory File Template