Index of every page on this site: llms.txt
All skills
github avatar

/vardoger-analyze

@f10fdb8 official
by githubgithub/awesome-copilot41k stars
5,399
Run it yourself

Use when the user asks to personalize the GitHub Copilot CLI assistant, adapt Copilot to their style, use vardoger, or analyze their Copilot CLI conversation history. Reads the local session directory at `~/.copilot/session-state/`, extracts recurring preferences and conventions, and writes a fenced personalization block into `~/.copilot/copilot-instructions.md`. Runs entirely on the user's machine via the local `vardoger` CLI (`pipx install vardoger`); no network calls and no uploads. Triggers: 'personalize my copilot', 'analyze my copilot history', 'tailor copilot to me', 'run vardoger', 'update my copilot instructions from history', 'make copilot learn my style'.

Use this Skill: https://skilld.dev/gh/github/awesome-copilot/vardoger-analyze

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈173 tokens for metadata: the name and description. ≈1.2k when used: this file.

Description uses 8.7% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈693 characters, or 8.7%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Analyze Copilot CLI history and generate personalized instructions

Drive the local vardoger CLI to read the user's GitHub Copilot CLI conversation history, extract behavioral patterns, and write a personalization block into ~/.copilot/copilot-instructions.md.

How it works

vardoger prepares the history in batches. You (the assistant) summarize each batch for behavioral signals, then synthesize all summaries into a final personalization. vardoger writes the result, fenced by <!-- vardoger:start --> / <!-- vardoger:end --> markers so any hand-authored rules in the same file are preserved.

Sandbox note (read before running any command)

vardoger reads and writes files outside the current workspace:

  • Reads Copilot CLI history from ~/.copilot/session-state/.
  • Writes a checkpoint state file to ~/.vardoger/state.json (created on first run).
  • Writes the final personalization to ~/.copilot/copilot-instructions.md.

When the host asks to approve a vardoger command, grant it write access beyond the workspace. Otherwise the first vardoger prepare call will fail with PermissionError: ... ~/.vardoger/state.tmp because the sandbox blocks writes outside the current working directory.

Workflow

  1. Verify the vardoger CLI is installed and fail fast with install guidance if not.
  2. Check staleness with vardoger status --platform copilot --json and stop early if the personalization is still fresh.
  3. Get batch metadata with vardoger prepare --platform copilot to learn the number of batches.
  4. For each batch, run vardoger prepare --platform copilot --batch <N> and write a concise bullet summary of the behavioral signals.
  5. Get the synthesis prompt with vardoger prepare --platform copilot --synthesize.
  6. Synthesize all batch summaries into a single personalization following the synthesis prompt.
  7. Write the result by piping the personalization into vardoger write --platform copilot --scope global (or --scope project --project <path>).
  8. Report back to the user what was written, where, and that the write is idempotent.

Steps

1. Verify vardoger is installed

if ! command -v vardoger >/dev/null 2>&1; then
  cat <<'INSTALL_EOF'
vardoger CLI is not installed.

This skill calls the `vardoger` CLI to read your Copilot CLI history and
write a personalization file, so the CLI must be on PATH.

Install options:

  # Recommended:
  pipx install vardoger

  # Or run without installing:
  uvx vardoger --help

If you do not have pipx, see https://pipx.pypa.io/stable/installation/.

Project page: https://github.com/dstrupl/vardoger

After installing, re-run the personalization request.
INSTALL_EOF
  exit 1
fi

2. Check if a refresh is needed

vardoger status --platform copilot --json

If the output shows "is_stale": false, tell the user their personalization is up to date and ask if they want to re-run anyway. If stale or never generated, continue with the analysis.

3. Get batch metadata

vardoger prepare --platform copilot

This prints JSON like {"batches": 3, "total_conversations": 29}. Note the number of batches. Tell the user: "Found N conversations in M batches. Analyzing..."

4. Summarize each batch

For each batch number from 1 to N, run:

vardoger prepare --platform copilot --batch 1

The output contains a summarization prompt followed by conversation data. Read the output carefully and produce a concise bullet-point summary of the behavioral signals you observe in that batch. Keep your summary for later.

Tell the user which batch you are processing: "Analyzing batch 1 of N..."

Repeat for all batches (--batch 2, --batch 3, etc.).

5. Get the synthesis prompt

vardoger prepare --platform copilot --synthesize

6. Synthesize the personalization

Following the synthesis prompt, combine all your batch summaries into a single personalization. The output should be clean markdown with actionable instructions for an AI assistant.

7. Write the result

Pipe your personalization to vardoger:

echo "YOUR_PERSONALIZATION_HERE" | vardoger write --platform copilot --scope global

Replace YOUR_PERSONALIZATION_HERE with the actual personalization markdown you generated. --scope global writes to ~/.copilot/copilot-instructions.md; use --scope project --project <path> to scope the write to a specific repository instead.

8. Report to the user

Tell the user what was written and where. Mention they can ask you to re-run vardoger any time to update the personalization, and that writes are idempotent (the fenced block is replaced; anything outside it is preserved).

When to use

  • When the user asks to personalize their Copilot CLI assistant.
  • When the user asks to analyze their Copilot CLI conversation history.
  • When the user mentions "vardoger".

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

1 alert1mo3 checks · Risk HIGH
  • Gen Agent Trust Hub1mo

    This skill analyzes private GitHub Copilot conversation history to personalize the assistant. It requires the installation of a third-party tool and explicitly instructs users to bypass security sandbox restrictions to modify configuration files outside the designated workspace.

  • Socket1mo

    No alerts

  • Snyk1mo

    Risk: LOW · No issues

Signed by skilld at f10fdb8. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub yesterday.

Activeupdated 7 months ago
  • CLI
  • Python
  • github-copilot
  • personalization
  • history-analysis
  • vardoger
  • local-first

README badge

README badge for github/awesome-copilot/vardoger-analyze

Analyzes GitHub Copilot CLI conversation history via the local `vardoger` CLI to extract behavioral patterns and writes a personalized instruction block to `~/.copilot/copilot-instructions.md`. Runs entirely on-machine with no network calls; reads from `~/.copilot/session-state/` and preserves hand-authored rules in the instructions file.

Generated from the current SKILL.md.

Does this work with GitHub Copilot in VS Code or JetBrains?
No. This skill is specific to the GitHub Copilot CLI. It reads conversation history from `~/.copilot/session-state/` and writes instructions to `~/.copilot/copilot-instructions.md`.
Does vardoger send my conversation history to the network?
No. The skill runs entirely on your machine via the local `vardoger` CLI. There are no network calls and no uploads of your history.
Will this overwrite my existing Copilot instructions?
No. The personalization is written inside fenced markers (`<!-- vardoger:start -->` / `<!-- vardoger:end -->`), so any hand-authored rules outside the fence are preserved.
Do I need to install vardoger separately?
Yes. The skill checks for `vardoger` on PATH and provides install guidance if missing. The recommended install is `pipx install vardoger`.
Can I scope the personalization to a single project instead of globally?
Yes. Use the `--scope project --project <path>` flag when writing to target a specific repository instead of `~/.copilot/copilot-instructions.md`.

Generated from the current SKILL.md. These answers refresh after source changes.