Agent skill

Crystallize

Distils repeating patterns from session logs and lessons.md into draft skill files.

MITAuto-check: notes

Install Crystallize

skills CLI

$ npx skills add avelikiy/great_cto --skill crystallize -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI

$ gh skill install avelikiy/great_cto crystallize --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy

$ git clone --depth 1 https://github.com/avelikiy/great_cto.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/crystallize .claude/skills/crystallize && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Paste into Claude Code

Install the "crystallize" agent skill from https://github.com/avelikiy/great_cto/tree/main/skills/crystallize into .claude/skills/crystallize/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "crystallize", then confirm the skill loads.

Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

$skill-installer

$skill-installer install https://github.com/avelikiy/great_cto/tree/main/skills/crystallize

Type this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.

skills CLI

$ npx skills add avelikiy/great_cto --skill crystallize -a codex

Project install goes to .agents/skills/; add -g for ~/.codex/skills/.

GitHub CLI

$ gh skill install avelikiy/great_cto crystallize --agent codex

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/avelikiy/great_cto.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/crystallize .agents/skills/crystallize && rm -rf skills-src

Use ~/.agents/skills/ instead of .agents/skills for a personal install.

Codex skills documentation · loads skills from .agents/skills/

Paste into Codex

Install the "crystallize" agent skill from https://github.com/avelikiy/great_cto/tree/main/skills/crystallize into .agents/skills/crystallize/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "crystallize", then confirm the skill loads.

Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add avelikiy/great_cto --skill crystallize -a cursor

Project install goes to .agents/skills/; add -g for ~/.cursor/skills/.

GitHub CLI

$ gh skill install avelikiy/great_cto crystallize --agent cursor

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/avelikiy/great_cto.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/crystallize .cursor/skills/crystallize && rm -rf skills-src

Use ~/.cursor/skills/ instead of .cursor/skills for a personal install.

Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/

Paste into Cursor

Install the "crystallize" agent skill from https://github.com/avelikiy/great_cto/tree/main/skills/crystallize into .cursor/skills/crystallize/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "crystallize", then confirm the skill loads.

Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

gemini skills install

$ gemini skills install https://github.com/avelikiy/great_cto.git --path skills/crystallize

--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.

skills CLI

$ npx skills add avelikiy/great_cto --skill crystallize -a gemini-cli

Project install goes to .agents/skills/; add -g for ~/.gemini/skills/.

GitHub CLI

$ gh skill install avelikiy/great_cto crystallize --agent gemini-cli

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/avelikiy/great_cto.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/crystallize .gemini/skills/crystallize && rm -rf skills-src

Use ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.

Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/

Paste into Gemini CLI

Install the "crystallize" agent skill from https://github.com/avelikiy/great_cto/tree/main/skills/crystallize into .gemini/skills/crystallize/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "crystallize", then confirm the skill loads.

Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

GitHub CLI

$ gh skill install avelikiy/great_cto crystallize

Installs for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).

skills CLI

$ npx skills add avelikiy/great_cto --skill crystallize -a github-copilot

Project install goes to .agents/skills/; add -g for ~/.copilot/skills/.

Manual copy

$ git clone --depth 1 https://github.com/avelikiy/great_cto.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/crystallize .github/skills/crystallize && rm -rf skills-src

Use ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.

GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/

Paste into GitHub Copilot

Install the "crystallize" agent skill from https://github.com/avelikiy/great_cto/tree/main/skills/crystallize into .github/skills/crystallize/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "crystallize", then confirm the skill loads.

GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add avelikiy/great_cto --skill crystallize -a opencode

OpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.

GitHub CLI

$ gh skill install avelikiy/great_cto crystallize --agent opencode

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/avelikiy/great_cto.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/crystallize .opencode/skills/crystallize && rm -rf skills-src

Use ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.

OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/

Paste into OpenCode

Install the "crystallize" agent skill from https://github.com/avelikiy/great_cto/tree/main/skills/crystallize into .opencode/skills/crystallize/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "crystallize", then confirm the skill loads.

OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

Facts

Skill name: crystallize
GitHub stars: 103
Token cost: ~1.1k tokens
SKILL.md length: 204 words
Files: 1
Skills in repo: 27
Repo updated: Oct 9, 2026
First seen: Oct 7, 2026
Licence: MIT

At a glance

Distils repeating patterns from session logs and lessons.md into draft skill files.

Works in 5 steps: Gather raw material → Cluster patterns (via… → Emit promotion report → …
SKILL.md covers Step 1 — Gather raw material, Step 2 — Cluster patterns (via…, Step 3 — Emit promotion report and Step 4 — Write…, plus 1 more section
Calls git and node

What it does

Crystallize is an agent skill from avelikiy/great_cto. Distils repeating patterns from session logs and lessons.md into draft skill files. Run after ≥10 sessions to extract durable knowledge. Output: draft skills/ files + promotion report.

Its SKILL.md is about 1.1k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

The repository describes itself as: You already have the agent. This is everything around it. greatcto runs Claude Code as a pipeline of 70 specialist agents — an independent model checks each stage before the next… The licence is MIT.

Example prompts

“Use the crystallize skill to distil repeating patterns from session logs and lessons.md into draft skill files”
“/crystallize”

Requirements

Pre-approved tools (allowed-tools): Read, Write, Glob, Grep, Bash, Agent

Workflow steps

5 steps, taken from the step headings in SKILL.md.

Gather raw material
Cluster patterns (via knowledge-extractor agent)
Emit promotion report
Write .last-crystallize marker
Auto-run cadence suggestion

What it can do on your machine

Read from SKILL.md and the folder at commit 5d6e760. It shows what the files ask for, not the result of running them.

Tool permissions
Pre-approves these tools, so the agent can use them without asking each time:
- Read
- Write
- Glob
- Grep
- Bash
- Agent
From allowed-tools in the SKILL.md frontmatter.
Runs code
Shell commands in SKILL.md call:
- git
- node
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md. Its commands use git, which can reach the network depending on how they are called.
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Crystallize loads about 1.1k tokens when it runs. Until then it costs about 49 tokens; SKILL.md has 204 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it: ~49
When it runs · the whole SKILL.md, loaded when a task matches: ~1.1k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

NotePre-approves every shell command (allowed-tools: Bash)SKILL.md
```
allowed-tools: Read, Write, Glob, Grep, Bash, Agent
```

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from avelikiy/great_cto at commit 5d6e760, republished under its MIT licence (© avelikiy). 204 words, ~1,086 tokens.

Download SKILL.mdSave it as .claude/skills/crystallize/SKILL.md (or your agent's skills folder).

name: crystallize
description: Distils repeating patterns from session logs and lessons.md into draft skill files. Run after ≥10 sessions to extract durable knowledge. Output: draft skills/ files + promotion report.
allowed-tools: Read, Write, Glob, Grep, Bash, Agent
when_to_use: Apply when: - CTO says /crystallize, "crystallize", or "extract knowledge" - Session count in .great_cto/logs/ reaches a multiple of 10 (auto-suggest) - User…
effort: high
paths: .great_cto/logs/**, .great_cto/lessons.md, ~/.great_cto/decisions.md, skills/**

Crystallize — distil session patterns into reusable skills

Invoke when the CTO says /crystallize, "crystallize", "extract knowledge", or "what have we learned?". Also auto-suggested when session count is a multiple of 10 (the session-end hook checks .great_cto/.last-crystallize).

The knowledge-extractor agent (Opus) does the heavy lifting. This skill orchestrates the workflow and emits the final report.

Session-end hint integration: The session-end hook checks .great_cto/.last-crystallize and suggests running /crystallize when the session count exceeds last_sessions + 10. Run this skill after ≥10 sessions to keep extracted skills current.

Step 1 — Gather raw material

bash

# Count sessions
SESSION_COUNT=$(ls .great_cto/logs/session-*-end.md 2>/dev/null | wc -l | tr -d ' ')
echo "Sessions: $SESSION_COUNT"

# Read lessons
cat .great_cto/lessons.md 2>/dev/null || echo "(no lessons yet)"

# Read cross-project decisions
cat ~/.great_cto/decisions.md 2>/dev/null | head -200 || echo "(none)"

# Find patterns that appear in ≥3 sessions
grep -h "^## pattern:" .great_cto/logs/session-*-end.md 2>/dev/null | sort | uniq -c | sort -rn | head -20

# Recent git log for context
git log --oneline --since="30 days ago" | head -30

If SESSION_COUNT is 0, tell the CTO: "No session logs found in .great_cto/logs/. Run at least 10 sessions before crystallizing." Exit.

If SESSION_COUNT < 10, tell the CTO: "Only {N} sessions found. Patterns are more reliable after ≥10 sessions. Proceed anyway? [yes/no]" Wait for confirmation before continuing.

Step 2 — Cluster patterns (via knowledge-extractor agent)

Spawn the knowledge-extractor agent with the gathered data as context:

Agent: knowledge-extractor
Task: |
  Read .great_cto/lessons.md and all files in .great_cto/logs/.
  Cluster lesson entries by pattern slug.
  For each cluster with ≥3 occurrences, write a draft skill file to
  skills/{domain}/SKILL.md (status: draft in frontmatter).
  If a skill for that domain already exists, append a new ## section instead
  of replacing the file.
  Infer domain from the pattern slug and its archetype tags.
  Return a structured summary: clusters found, drafts written, already-covered.

Wait for the agent to complete before proceeding to Step 3.

Step 3 — Emit promotion report

After the agent completes, print:

CRYSTALLIZE REPORT
════════════════════════════════════════
Sessions analysed: {SESSION_COUNT}
Lessons found:     {LESSON_COUNT}
Clusters:          {CLUSTER_COUNT}
Draft skills:      {DRAFT_COUNT}  (in skills/{domain}/SKILL.md)
Already covered:   {COVERED_COUNT}  (pattern already in existing skill)
════════════════════════════════════════
Draft files:
  {list of paths and brief description per draft}

Next: review drafts, remove `status: draft` when satisfied.
Run /crystallize again after 10 more sessions.
════════════════════════════════════════

Step 4 — Write .last-crystallize marker

After emitting the report, write the marker file:

bash

SESSION_COUNT=$(ls .great_cto/logs/session-*-end.md 2>/dev/null | wc -l | tr -d ' ')
DRAFT_COUNT={P}   # from agent output
mkdir -p .great_cto
node -e "
const fs = require('fs');
fs.writeFileSync('.great_cto/.last-crystallize', JSON.stringify({
  ts: new Date().toISOString(),
  sessions: parseInt('$SESSION_COUNT') || 0,
  drafts: parseInt('$DRAFT_COUNT') || 0
}) + '\n');
"

Step 5 — Auto-run cadence suggestion

If SESSION_COUNT is a multiple of 10 (and > 0), append to the report:

Auto-suggestion: you've completed {SESSION_COUNT} sessions. Consider running
`/crystallize` every 10 sessions to keep skills current.

Files

Just SKILL.md in skills/crystallize of avelikiy/great_cto.

Open the folder on GitHubat commit 5d6e760

Compare with similar skills

Crystallize next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Crystallize compared with similar skills
Skill	Stars	Used in	Tokens	Auto-check	Licence	Repo updated
Crystallize this skillavelikiy/great_cto	103	—	~1.1k	Automated safety check: Notes	MIT	today
Lesson Memory Recorderrohitg00/agentmemory	29k	—	~721	Automated safety check: Pass	Apache-2.0	today
Growth Logaffaan-m/ECC	276k	1 repos	~1.7k	Automated safety check: Pass	MIT	4 days ago
Clickhouse Logs Queriessupabase/supabase	111k	—	~2.4k	Automated safety check: Pass	Apache-2.0	today
Paperclip Distillpaperclipai/paperclip	99k	—	~2.8k	Automated safety check: Pass	MIT	today
Investigating LogsPostHog/posthog	40k	—	~2.1k	Automated safety check: Pass	Custom licence	today

Similar skills

Lesson Memory Recorder
rohitg00/agentmemory
Distills a user correction or hard-won rule into a confidence-weighted lesson that resurfaces automatically before similar future work.
29k GitHub stars~721 tokensUpdated today
Agent WorkflowsAuto-check passed
Growth Log
affaan-m/ECC
Write growth log entries that extract reusable patterns from completed work — root cause, transferable rule, and a recognizable signal — instead of diary-style event narration, with a 4-8 sentence…
276k GitHub starsUsed in 1 repo~1.7k tokens
DevelopmentAuto-check passed
Clickhouse Logs Queries
supabase/supabase
Official
Write, review, and migrate Supabase logs queries against the ClickHouse-backed logs table (the logs.all.otel analytics endpoint).
111k GitHub stars~2.4k tokensUpdated today
DatabasesAuto-check passed
Paperclip Distill
paperclipai/paperclip
A skill your agent uses when an operation issue is a Paperclip cursor-window, distill, or backfill.
99k GitHub stars~2.8k tokensUpdated today
Productivity & AutomationAuto-check passed
Investigating Logs
PostHog/posthog
Official
Investigate logs in a PostHog project: verify a service or deployment is healthy, explain an error spike, triage an incident, or understand what a log stream is saying.
40k GitHub stars~2.1k tokensUpdated today
DatabasesAuto-check passed
Logging and Error Reporting for Warp
warpdotdev/warp
Guides log level choices and when to raise a structured Sentry event instead of a plain log line in the Warp Rust codebase, keeping secrets out of logs.
65k GitHub starsUsed in 1 repo~5.6k tokens
DevelopmentAuto-check passed

Questions about Crystallize

What does Crystallize do?

Distils repeating patterns from session logs and lessons.md into draft skill files. Crystallize is an agent skill from avelikiy/great_cto.md into draft skill files.

How do I install Crystallize in Claude Code?

Run `npx skills add avelikiy/great_cto --skill crystallize -a claude-code`. Or copy the skill folder (skills/crystallize in avelikiy/great_cto) into .claude/skills/crystallize in your project. Claude Code loads it when a task matches its description.

How do I install Crystallize in Codex?

Run `npx skills add avelikiy/great_cto --skill crystallize -a codex`. Or copy the skill folder (skills/crystallize in avelikiy/great_cto) into .agents/skills/crystallize in your project. Codex loads it when a task matches its description.

Can I use Crystallize in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add avelikiy/great_cto --skill crystallize -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/crystallize, .gemini/skills/crystallize, .github/skills/crystallize and .opencode/skills/crystallize in your project.

What does Crystallize need to run?

Going by SKILL.md and its folder, Crystallize needs the command-line tools its instructions call (git and node). Its frontmatter pre-approves these tools: Read, Write, Glob, Grep, Bash, Agent.

Does Crystallize access the network?

SKILL.md contains no URLs. Its commands use git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Crystallize safe to install?

Our automated static check of SKILL.md found notes only (pre-approves every shell command (allowed-tools: bash)), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Crystallize use?

Crystallize is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Crystallize use?

About 1.1k tokens (SKILL.md is roughly 4.3k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Crystallize?

Skills that share tags, products or a category with Crystallize: Lesson Memory Recorder (rohitg00/agentmemory, 29k stars), Growth Log (affaan-m/ECC, 276k stars), Clickhouse Logs Queries (supabase/supabase, 111k stars) and Paperclip Distill (paperclipai/paperclip, 99k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Crystallize?

avelikiy (a GitHub user) maintains it in avelikiy/great_cto, which has 103 GitHub stars. The repository holds 27 skills in this directory. The repository was last updated on October 9, 2026.

Source: avelikiy/great_cto on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.

Crystallize

Install Crystallize

Facts

At a glance

What it does

Example prompts

Requirements

Workflow steps

What it can do on your machine

Tool permissions

Runs code

Network

Credentials

Context cost

Safety

SKILL.md

Crystallize — distil session patterns into reusable skills

Step 1 — Gather raw material

Step 2 — Cluster patterns (via knowledge-extractor agent)

Step 3 — Emit promotion report

Step 4 — Write .last-crystallize marker

Step 5 — Auto-run cadence suggestion

Files

Compare with similar skills

Similar skills

Lesson Memory Recorder

Growth Log

Clickhouse Logs Queries

Paperclip Distill

Investigating Logs

Logging and Error Reporting for Warp

More from avelikiy/great_cto

AnyDesign Design Analyzer

Opportunity Solution Tree

Outcome-Focused Roadmap Rewriter

Exposed Secret Rotation

Skeptical Triage

Aesthetic Instrument

Questions about Crystallize