ES6KR Skills (es6kr/skills)

ES6KR Skills

https://github.com/es6kr/skills
Admin
Reusable AI coding skills for Claude Code, Cursor, Codex, and Gemini, including TDD, commit...

Tokens:71,860
Snippets:1,017
Trust Score:7.2
Update:1 month ago
Show doc for...
Context Summary (auto-generated)
Raw
# ES6KR Skills

ES6KR Skills is a comprehensive collection of reusable AI coding skills designed for Claude Code, Cursor, Codex, and Gemini. These skills automate common development workflows including Test-Driven Development (TDD), commit management, dotfile synchronization, session management, and Git repository operations. The collection provides structured automation patterns that enhance AI-assisted coding by providing domain-specific instructions, workflow guidance, and integration with development tools.

The skill collection follows a multi-topic architecture where each skill contains a main `SKILL.md` file with frontmatter metadata and optional topic files for specialized sub-features. Skills are automatically activated based on description matching and trigger keywords, allowing Claude to seamlessly apply the appropriate skill when users mention relevant concepts. The collection supports both global installation (`~/.claude/skills/`) for personal use and project-level installation (`.claude/skills/`) for team collaboration.

## TDD Skill - Test-Driven Development Workflow

The TDD skill implements the Red-Green-Refactor cycle for test-driven development. It guides the AI to define expected behavior first through tests, then implement the minimum code to make tests pass, and finally refactor while ensuring tests remain green.

```bash
# TDD Cycle Workflow
# Step 1: Red - Write a failing test that defines expected behavior
# Step 2: Green - Implement minimum code to pass
# Step 3: Refactor - Clean up while tests pass

# Example TDD session for a utility function
/tdd cycle

# The skill enforces these rules:
# - Read production code before writing tests
# - Use actual functions, not hardcoded values
# - Explore existing tests to avoid duplicates
# - Use OS-native APIs (os.homedir(), path.join())

# Bug-fix TDD pattern
# 1. Write test capturing the bug
# 2. Verify test fails (bug exists)
# 3. Fix implementation
# 4. Verify test passes
```

```typescript
// Platform-specific test example (enforced by TDD skill)
import * as os from 'os';
import * as path from 'path';

// CORRECT: Use OS native APIs
const homeDir = os.homedir();
const filePath = path.join(homeDir, 'projects', 'work');

// WRONG: Hardcoded platform values
// const homeDir = 'C:\\Users\\test';  // Never do this
// const filePath = homeDir + '\\projects';  // Never concatenate manually
```

## Skill-Kit - Skill Lifecycle Management

The skill-kit provides tools for creating, validating, upgrading, and managing Claude Code skills. It includes a writer wizard for creating properly structured skills with validated frontmatter.

```bash
# Create a new skill with the interactive wizard
/skill-kit writer

# Validate and fix skill frontmatter
/skill-kit lint skill-name

# Upgrade existing skill with new topics
/skill-kit upgrade skill-name

# Compile triggers and auto-generate hooks
/skill-kit trigger compile

# Find duplicate skills
/skill-kit dedup

# Merge related skills into one multi-topic skill
/skill-kit merge skill-a skill-b
```

```yaml
# SKILL.md frontmatter structure
---
name: my-skill
description: |
  Brief description of what this does and when to use it.
  Include trigger keywords like "my feature", "do something".
depends-on: [other-skill]
allowed-tools: [Read, Grep, Glob, Bash(git:*)]
---

# Skill Name

Brief overview.

## Quick Start
Simple example to get started.

## Instructions
Step-by-step guidance.

## Examples
Concrete usage examples.
```

```
# Multi-topic skill directory structure
skill-name/
├── SKILL.md          # Main file with frontmatter + overview
├── topic-a.md        # Topic file for sub-feature A
├── topic-b.md        # Topic file for sub-feature B
└── scripts/
    └── helper.js     # Supporting scripts
```

## Claude-Session - Session Management

The claude-session skill provides comprehensive session management including ID lookup, compression, analysis, migration between projects, and repair of broken session structures.

```bash
# Look up current session ID
/session id

# Search sessions by keyword
/session id Makefile remove

# Search only today's sessions by file path
/session id --today ansible/Makefile

# Summarize a specific session
/session summarize <session_id>

# Analyze session statistics and tool usage
/session analyze
/session analyze <session_id>
/session analyze --sync  # Sync to Serena memory

# Compress sessions via UTCP/code-mode
/session compress <session_id>

# Classify and organize sessions (delete/keep/extract)
/session classify
/session classify --depth=medium

# Migrate sessions between projects (main repo to worktree)
/session migrate
/session migrate --dry-run
/session migrate <source> <target>

# Repair broken session structure
/session repair
/session repair <session_id> --dry-run

# Delete dead sessions (hook-only, no assistant response)
/session purge
/session purge --all

# Assign custom title to session
bash scripts/rename-session.sh <session_id> "name"
bash scripts/rename-session.sh --list
```

```bash
#!/usr/bin/env bash
# find-session-id.sh - Find current session ID by searching for a unique marker
# Usage: find-session-id.sh <marker> [project_dir]

CLAUDE_PROJECTS_DIR="$HOME/.claude/projects"

# Convert CWD to Claude Code project name
cwd_to_project_name() {
    local cwd="$1"
    cwd="${cwd%/}"
    echo "$cwd" | sed 's/[^a-zA-Z0-9]/-/g'
}

MARKER="${1:-}"
PROJECT_NAME=$(cwd_to_project_name "$(pwd)")
PROJECT_DIR="$CLAUDE_PROJECTS_DIR/$PROJECT_NAME"

# Search for marker in session files
RESULT=$(grep -rl "$MARKER" "$PROJECT_DIR"/*.jsonl 2>/dev/null | grep -v 'sync-conflict' | head -1)
SESSION_ID=$(basename "$RESULT" .jsonl)
echo "$SESSION_ID"
```

## Git-Repo - Repository Management

The git-repo skill manages Git repositories and SourceGit GUI client integration, including ghq cloning with automatic registration, repository migration, and batch inspection.

```bash
# Clone with ghq and auto-register in SourceGit
ghq get https://github.com/org/repo.git

# Migrate repository to ghq structure
/git-repo migrate

# Batch inspect all ghq repositories
/git-repo patrol

# Fix bare repo worktree configuration
/git-repo fix-worktree

# Merge duplicate repositories
/git-repo merge-duplicate
```

```bash
# Pre-clone check for existing repositories
# Check bare repository (ghq doesn't check this automatically)
ls ~/ghq/host/group/repo.git 2>/dev/null

# Detect broken repository from failed clone
cd ~/ghq/host/group/repo && git status 2>&1
# "fatal: not a git repository" = broken state

# Move broken directory and re-clone
mv ~/ghq/host/group/repo ~/.claude/.bak/repo_$(date +%Y%m%d)
ghq get <url>

# GitHub multi-account clone (when gh auth switch has bugs)
TOKEN=$(gh auth token --user <GITHUB_USER> 2>/dev/null)
git clone "https://<GITHUB_USER>:${TOKEN}@github.com/org/repo.git" ~/ghq/github.com/org/repo

# Remove token from origin after cloning
git -C ~/ghq/github.com/org/repo remote set-url origin "https://github.com/org/repo.git"
```

```json
// SourceGit preference.json group structure
{
  "RepositoryNodes": [
    {
      "Id": "uuid-v4",
      "Name": "org-name",
      "IsRepository": false,
      "IsExpanded": true,
      "SubNodes": [
        {
          "Id": "/Users/user/ghq/github.com/org/repo",
          "Name": "repo",
          "IsRepository": true,
          "SubNodes": []
        }
      ]
    }
  ]
}
```

## Chezmoi - Dotfile Template Management

The chezmoi skill manages dotfile templates, consolidates duplicate templates, handles cross-platform compatibility, and synchronizes MCP server configurations across multiple applications.

```bash
# Check for duplicate templates
/chezmoi consolidate

# Cross-platform diagnostics (macOS/Windows)
/chezmoi cross-platform

# Check required files and auto-copy if missing
/chezmoi doctor

# MCP server synchronization
/chezmoi mcp-sync
```

```
# Chezmoi directory structure
~/.local/share/chezmoi/
├── .chezmoi-lib/              # Shared scripts
│   ├── executable_vscode-settings.sh
│   ├── executable_mcp-servers.sh
│   └── executable_sourcegit-preference.sh
├── .chezmoitemplates/         # Shared data
│   └── mcp-servers.json       # MCP server single source of truth
├── .chezmoiignore             # OS-specific path branching
├── modify_*.sh.tmpl           # Per-app modify templates
├── private_Library/           # macOS app settings
└── AppData/                   # Windows app settings
```

```json
// MCP server single source of truth format
// Location: ~/.local/share/chezmoi/.chezmoitemplates/mcp-servers.json
{
  "server-name": {
    "transport": "stdio",
    "command": "npx",
    "args": ["-y", "package-name"]
  }
}
```

```bash
# Apply chezmoi changes (always preview first)
chezmoi diff
chezmoi apply

# Verify MCP propagation to each app
jq '.mcpServers | keys' ~/.claude.json
jq '.mcpServers | keys' ~/.cursor/mcp.json
jq '.manual_call_templates[].name' ~/.utcp_config.json
```

## Commit-Tidy - Commit Analysis and Splitting

The commit-tidy skill analyzes staged/committed changes and recommends splitting or squashing strategies for atomic, reviewable commits.

```bash
# Analyze staged changes
git diff --cached --stat
git diff --cached --name-only

# Check unstaged changes
git diff --stat
git status
```

```
# Split recommendation output format
## Analysis Results

### Changed Files (7 files)
- src/api/... (3 files) - API endpoints
- src/components/... (2 files) - UI components
- tests/... (2 files) - Tests

### Recommendation: Split into 2 commits

**Commit 1**: feat: add user profile API
- src/api/user.ts
- src/api/types.ts
- tests/api/user.test.ts

**Commit 2**: feat: add profile UI component
- src/components/Profile.tsx
- src/components/Profile.css

### Reasoning
- API and UI can function independently
- Each can be reviewed by different reviewers
```

```bash
# Execute split
git reset HEAD
git add src/api/ tests/api/
git commit -m "feat: add user profile API"
git add src/components/
git commit -m "feat: add profile UI component"
```

```
# Squash recommendation output format
### Recommendation: Squash 2 commits → 1

**Before** (2 commits):
- 441b966a test(dt): OIDC auth, proxy, SSO tests
- e2b6503a test(dt): OIDC route tests (login, callback, me)

**After** (1 commit):
- test(dt): add OIDC auth unit tests

**Reasoning**: Same type (test), same feature (OIDC auth), agent loop split
```

## Claudify - Workflow Automation Conversion

The claudify skill converts functionality into Claude Code automation types (Agent, Skill, Rule, Command, or Hook) based on use case analysis.

```
# Decision Matrix
| Type          | When to use              | Location                    |
|---------------|--------------------------|------------------------------|
| Agent         | High autonomy, multi-tool| .claude/agents/name.md       |
| Skill         | Domain expertise, logic  | .claude/skills/name/SKILL.md |
| Rule          | Constraints, styling     | .claude/rules/name.md        |
| Slash Command | User types /cmd          | .claude/commands/name.md     |
| Hook          | Events (tool use, etc)   | .claude/settings.json        |
```

```
# File Locations Reference
| Type    | Global                           | Project                      |
|---------|----------------------------------|------------------------------|
| Skill   | ~/.claude/skills/name/SKILL.md   | .claude/skills/name/SKILL.md |
| Agent   | ~/.claude/agents/name.md         | .claude/agents/name.md       |
| Rules   | ~/.claude/rules/name.md          | .claude/rules/name.md        |
| Command | ~/.claude/commands/name.md       | .claude/commands/name.md     |
| Hook    | ~/.claude/settings.json          | .claude/settings.json        |
```

```
# Skill with scripts directory structure
skill-name/
├── SKILL.md          # frontmatter + documentation
├── topic-a.md        # topic file
├── topic-b.md        # topic file
└── scripts/
    └── helper.js     # actual logic
```

## Code-Workflow - Research-Plan-Implement Process

The code-workflow skill implements a 4-stage workflow for code changes: Research, Plan, User Review, and Implement (with TDD by default).

```bash
# Research phase - write findings to file
# Location: .ralph/docs/generated/research-<task>.md

# Plan phase - write implementation plan
# Location: .ralph/docs/generated/plan-<task>.md

# Plan should include:
# - Detailed approach description
# - Code snippets showing actual changes
# - List of file paths to be modified
# - Verification plan with commands and expected results

# Implementation phase with TDD (default)
/code-workflow implement

# Skip TDD if specified
/code-workflow implement --no-tdd

# Revert and restart if going wrong direction
git checkout -- <files>
```

```
# Task Complexity Guide
| Complexity | Scope                              | Action              |
|------------|------------------------------------|--------------------|
| trivial    | 1-2 line edits, config changes     | Implement directly  |
| moderate   | 3-10 files, logic changes          | Start from plan     |
| complex    | 10+ files, new features, arch      | Full workflow       |
```

## MCP-Config - MCP Server Configuration

The mcp-config skill manages MCP server configuration in `.mcp.json` files with proper scope selection and validation.

```bash
# Add MCP server
/mcp-config add

# Move server scope (project → local, local → user)
/mcp-config move

# View catalog of commonly used servers
/mcp-config catalog

# Check JSON format differences per agent
/mcp-config format
```

```json
// MCP server entry format
{
  "server-name": {
    "transport": "stdio",
    "command": "npx",
    "args": ["-y", "package-name"],
    "env": {
      "API_KEY": "value"
    }
  }
}
```

## TodoWrite - TODO Routing

The todowrite skill routes TODO checklists to appropriate storage based on context: session tracking, file-based persistence, or GitHub Issues for team sharing.

```
# Routing Decision Tree
New TODO arrives
  ├─ Only needed this session → /wip (TaskCreate/TodoWrite)
  ├─ Persists beyond session → file (fix_plan.md, TODO.md)
  └─ Team-shared → issue (GitHub Issues)
```

```markdown
## fix_plan.md format (Ralph projects)

## Pending

- [ ] Item 1 — description
- [ ] Item 2 — description

## Completed

- [x] Done item — (completed: 2026-04-03, commit abc1234)
```

```bash
# Create GitHub issue for team-shared TODOs
gh issue create --title "Item" --body "Description"
gh issue list --label "todo"
```

## WIP - Work In Progress Tracking

The WIP skill tracks in-session work progress using TodoWrite or TaskCreate for multi-step tasks.

```typescript
// TodoWrite pattern for sequential steps
TodoWrite([
  { content: "Step 1 description", status: "in_progress", activeForm: "Doing step 1" },
  { content: "Step 2 description", status: "pending", activeForm: "Doing step 2" },
  { content: "Step 3 description", status: "pending", activeForm: "Doing step 3" }
])

// After step 1 completes
TodoWrite([
  { content: "Step 1 description", status: "completed", activeForm: "Doing step 1" },
  { content: "Step 2 description", status: "in_progress", activeForm: "Doing step 2" },
  { content: "Step 3 description", status: "pending", activeForm: "Doing step 3" }
])
```

```typescript
// TaskCreate pattern for parallel independent tasks
TaskCreate({ subject: "Modify file A", status: "pending" })
TaskCreate({ subject: "Modify file B", status: "pending" })
TaskCreate({ subject: "Run tests", status: "pending", addBlockedBy: ["1", "2"] })

// Update progress
TaskUpdate({ taskId: "1", status: "in_progress" })
TaskUpdate({ taskId: "1", status: "completed" })
```

## Next-Action - Follow-up Suggestions

The next-action skill automatically suggests 2-4 logical follow-up actions after task completion using AskUserQuestion.

```typescript
// After code modification
AskUserQuestion({
  questions: [{
    question: "What would you like to do next?",
    header: "Next Action",
    multiSelect: true,
    options: [
      { label: "Run tests", description: "Verify changes with test suite" },
      { label: "Commit", description: "Git commit the changes" }
    ]
  }]
})

// After commit
options: [
  { label: "Push", description: "Git push to remote" },
  { label: "Create PR", description: "Create Pull Request" }
]

// After complex workflow
options: [
  { label: "Agentify", description: "Convert this workflow to an agent/skill" },
  { label: "Serena memory", description: "Save key learnings to Serena memory" }
]
```

## Fix - Behavior Correction

The fix skill handles user feedback with "fix:" prefix, analyzing mistakes and improving rules/skills/hooks to prevent recurrence.

```
# Fix procedure
1. Root cause analysis - identify what went wrong
2. Root cause fix - improve skill/rule/hook (priority order)
3. Fix current issue - resolve the immediate problem
4. Completion report - summarize changes

# Priority for fixes:
1st: Skill (if procedure is incomplete)
2nd: Rule (if behavior rule is missing)
3rd: Hook (if automation is needed)
4th: SKILL.md docs (if documentation is wrong)
```

```
# Completion report format
Fix complete:
- Root cause: {what was missing}
- Improvement: {which file was modified and how}
- Current fix: {result of fixing the current issue}
```

## Dotfile Sync - External Tool Synchronization

The dotfile skill manages data synchronization with external tools including Serena, chezmoi, and Syncthing.

```bash
# Knowledge sync to Serena memory
/sync knowledge

# Chezmoi dotfile management
/sync chezmoi

# MCP server sync (delegates to chezmoi)
/sync mcp

# Syncthing diagnostics
/sync syncthing
```

```
# Configurations managed by chezmoi
~/.utcp_config.json          # UTCP global config
~/.claude.json               # Claude MCP config
~/.cursor/mcp.json           # Cursor MCP config
~/Library/.../config.xml     # Syncthing default config
```

## Oh My Zsh - Plugin Management

The omz skill manages Oh My Zsh plugins and custom configurations.

```bash
# Add/install plugins to .zshrc plugins=() array
/omz plugin

# Write custom $ZSH_CUSTOM/*.zsh files
/omz custom
```

## Repo Init - Project Initialization

The repo skill provides project initialization including auto-generating CONTRIBUTING.md from project structure analysis.

```bash
# Generate CONTRIBUTING.md from project analysis
/init contributing

# What gets detected:
# - Requirements: Node.js version, package manager
# - Code Style: indent, EOL, charset from .editorconfig
# - Lint Config: ESLint rules, Prettier settings
# - Build Commands: scripts from package.json
# - Commit Convention: Conventional Commits format
# - Pre-commit Hooks: husky configuration
# - Monorepo Structure: package dependency graph
```

ES6KR Skills provides a comprehensive automation layer for AI-assisted development. The primary use cases include implementing TDD workflows with proper test-first development, managing Git repositories with SourceGit integration, maintaining consistent dotfile configurations across machines via chezmoi, and tracking session work with TodoWrite/TaskCreate patterns. The skills work together through dependencies (specified in frontmatter) and topic routing to handle complex multi-step workflows.

Integration follows a plugin architecture where skills are installed via `claude plugin marketplace add` for Claude Code or through ClawHub for other supported tools. Skills can be customized at both global (`~/.claude/skills/`) and project (`.claude/skills/`) levels. The skill-kit provides lifecycle management for creating, validating, and upgrading skills, while the claudify skill helps determine when to create new automation (Skill, Agent, Rule, Command, or Hook) based on the specific requirements of the workflow being automated.