Skill

Pass

Audit score 90

automate-me

cursor/plugins

Turn your working style into a personal agent skill that captures your preferences and conventions.

What is automate-me?

Automate-me guides you through creating a personalized `-mode` skill that encodes your working conventions, response preferences, and process habits. Use it when you want agents to work in your style, or to update an existing personal skill with new patterns from your recent work.

Mines your recent agent transcripts to identify recurring patterns in how you work
Asks targeted questions about your preferences, autonomy level, and verification posture
Clusters findings into operational sections (response style, code discipline, process, skills habits)
Drafts a personal `-mode` skill using Cursor's create-skill and unslop for prose discipline
Iterates with you until the skill accurately reflects your working conventions

How to install automate-me

npx skills add https://github.com/cursor/plugins --skill automate-me

Prerequisites

Active workspace with agent transcripts in `agent-transcripts/` directory
Cursor's built-in `create-skill` skill available
The `unslop` skill installed for prose discipline iteration

Claude Code

Cursor

Windsurf

Cline

How to use automate-me

1.Run the skill and confirm whether you're creating a new mode skill or updating an existing one
2.Let the skill mine your recent transcripts for patterns in response style, delegation, verification, and process
3.Answer structured multi-choice questions about which areas matter most to you
4.Review the clustered findings and provide free-form feedback on what's missing or incorrect
5.Iterate on the draft skill prose until it reads like you and captures your actual conventions
6.Commit the skill to a worktree and open a PR to land it

Use cases

Good for

Create a first personal mode skill by analyzing your chat history and preferences
Update an existing mode skill when your working style has evolved or you want to add new rules
Capture delegation habits and subagent preferences into a reusable skill
Codify your code and prose discipline standards so agents follow your style
Document your verification and review posture (unit tests vs live repro, reviewer workflows)

Who it's for

Individual developers wanting agents to work in their personal style
Teams with established working conventions ready to encode them into a shared mode skill
Users who frequently correct agents on the same preferences and want to automate that guidance

automate-me FAQ

What's the difference between a mode skill and a regular skill?

A mode skill (`<handle>-mode`) encodes your personal working conventions and applies when agents work with you. A regular skill is task-specific. Mode skills use `disable-model-invocation: true` by default so they don't trigger on every turn.

Can I update an existing mode skill?

Yes. The skill checks for existing `-mode` skills matching your handle and offers to update them. It will mine only history since the skill was last edited and ask what's changed or missing, rather than starting from zero.

Where does the skill get created?

By default, `.cursor/skills/<handle>-mode/SKILL.md` in your project, or `~/.cursor/skills/<handle>-mode/` if you prefer a personal skill. If you have an established personal category directory, it preserves that structure.

How does the skill mine my history?

It reads transcripts from your active workspace's `agent-transcripts/` directory only—never across other projects. It runs parallel subagents on slices of recent history (e.g., last 2-4 weeks) looking for patterns in response preferences, delegation, verification, code style, and process.

What if mining finds weak signals?

Patterns seen in only one transcript slice are dropped. The skill requires cross-checks across multiple slices before elevating a signal to the final skill, so you don't overfit to one conversation.

Full instructions (SKILL.md)

Source of truth, from cursor/plugins.

name: automate-me description: "Use for "automate me", "create/update/refresh my -mode skill", "turn/capture my preferences or working style into a skill", or wanting agents to follow how the user works. Drafts or revises a personal -mode skill via create-skill + unslop, optionally pulling fresh evidence from recent transcripts." disable-model-invocation: true

Automate me

A guided flow for turning the user's working conventions into a skill agents will follow. The output is one -mode skill tailored to them (e.g. jay-mode, priya-mode).

This skill orchestrates three others: an inline mining pass (see step 1), Cursor's built-in create-skill (authoring), and the unslop skill (prose discipline). It sequences them. It doesn't replace them.

Flow

0. Check for an existing skill

Look recursively for .cursor/skills/**/*-mode/SKILL.md and ~/.cursor/skills/*-mode/SKILL.md matching the user's handle. Mode skills can live in a personal category directory (.cursor/skills/<handle>/), not only at the top level. If one exists, confirm intent with AskQuestion (unless they already said "update my skill" or similar):

Update the existing skill (default for repeat runs)
Start fresh (rare, ask why before doing it)

Update mode changes the rest of the flow:

Step 1 mines only history since the skill was last edited (git log -1 --format=%cI <path>).
Step 2 asks what's changed or missing, not what to capture from zero.
Step 4 edits the existing file in place. Preserve sections the user hasn't contradicted. Revise ones with new evidence. Add new sections only for genuinely new rules.

1. Mine their history

Locate the active workspace's transcripts before fanning out. The system prompt names the workspace's agent-transcripts/ directory. Use only that path. Don't glob across ~/.cursor/projects/*/. That crosses workspace boundaries and reads private chats from unrelated projects.

Survey recent agent conversations within that scope for recurring patterns. Run multiple parallel subagents across slices of history (e.g. last 2-4 weeks, split into 3 slices so each has enough material). Each slice mining subagent reads transcripts from the workspace-scoped path the parent provides, looks for the signals below, and returns a short structured list of patterns it saw with evidence pointers. Default signals worth hunting:

Response preferences (length, tone, format, "dumb it down" corrections)
Delegation habits (subagents, models, specialized workflows, parallelism)
Verification posture (what "done" means, unit tests vs live repro, reviewers)
Code and prose discipline (style, principles cited, lint/format tools)
Process conventions (worktrees, commits, PRs, review/merge tooling)
Meta preferences (fixing skills mid-task, proposing new ones)

Cross-check across slices before elevating a signal. Patterns seen in 2+ slices are high-confidence. Lone signals are weak and usually get dropped.

2. Ask the user directly

Mining misses intent that hasn't come up yet. Use the AskQuestion tool (structured multi-choice) rather than asking the user to type from scratch.

Shape: one or two questions with 4-6 options each, allow_multiple: true for category questions. Start broad ("Which areas matter most?"), then follow up on selected areas with specific options. After the structured rounds, one free-form chat question catches anything the options missed.

Don't dump 20 questions.

3. Cluster findings

Group the combined signals into sections. Common ones (use only what applies):

Response style: length, tone, format.
Autonomy: how much to do without asking, MCP tool use.
Understand first: which skills to reach for when scoping or investigating a change.
Subagents: default, parallelism, model-to-task, specialized workflows.
Prose / code discipline: principles, lint tools, style guides.
Review and verify: repro posture, verification skills, live-testing tools.
Process: git worktrees, commits, PRs, review/merge tooling.
Skills: skill-authoring habits, fix-the-skill-first, proposing new skills.

The poteto-mode skill shows the shape. Read it for granularity. Don't copy its content. The user's rules are not the same as poteto-mode's.

4. Draft the skill

Use Cursor's built-in create-skill skill to author the skill. Placement:

Path: preserve an existing mode skill's category. For a new mode, use .cursor/skills/<handle>/<handle>-mode/SKILL.md when the repo has an established personal category for that handle. Otherwise default to .cursor/skills/<handle>-mode/SKILL.md in the project (or ~/.cursor/skills/<handle>-mode/ if the user prefers a personal skill).
Handle: the user's first name or chosen identifier.
Frontmatter description: trigger on their name + /<handle>-mode + "work in their style", not on generic keywords like "write code" or "review PR".
Frontmatter formatting: follow create-skill's YAML rules. Keep description as one YAML scalar. Quote it or use description: >- with indented continuation lines when punctuation or wrapping requires it.
Frontmatter disable-model-invocation: true by default. Opt out only if the user explicitly wants their mode to apply on every turn.

5. Iterate on prose

Apply the unslop skill and create-skill's writing guidelines to every line.

Show the draft to the user and take feedback. Expect multiple iterations. Cut ruthlessly. A mode skill is not a manual.

6. Land it

Work in a worktree off main. Commit and open a PR. Don't push to main directly.

Guardrails

Don't overfit to one conversation. A preference stated once and contradicted another time is noise. Require multiple instances before codifying it.
Don't be clever. Restating other skills' contents, inventing metaphors, or writing "poetic" prose for an agent reader is cost without benefit. Keep it operational.
Reference, don't inline. Other skills the user relies on should appear as path references, not pasted excerpts. Same for any principle docs they maintain elsewhere.
Keep sections minimal. Only add a section if the user has a specific, non-default rule there. "Communicate clearly" is not a section. "Short paragraphs. Tables when comparing options. Bullets only when items are genuinely parallel." is.
Name conventions generic. Use "the user" or "the human" in imperatives, not the author's first name.
Don't force symmetry. If a user has no process rules worth writing down, skip the Process section entirely.

Evaluation

A -mode skill is subjective output. A create-skill-style test/iterate benchmark loop isn't useful here. Vibe-check with the user: does it read like them? Did it miss anything? Then ship.

Run a description-optimization loop only if the skill's trigger accuracy turns out to be a problem in practice.

When not to use

User wants a task-specific skill (not working conventions): create-skill alone, no mining required.
User wants to capture one narrow workflow (e.g. "how I write commit messages"). That's a regular skill, not a mode skill.