jackchuka/skills

# Permissions Audit

Review and reorganize Claude Code permission settings so global settings are the
source of truth, project-local files stay minimal, and read vs write operations
have clear separation.

## When to Use

- Reviewing what tools and commands are pre-allowed
- Cleaning up accumulated ad-hoc permission entries
- After adding a new MCP server and deciding which operations to pre-allow
- Ensuring global vs project-local settings are properly split
- Periodic hygiene check on permission sprawl

# Skill Orchestration Audit

Check skills against orchestration best practices in `references/subagent-orchestration-best-practices.md`.

## Arguments

- **Skill names**: filter to specific skills
- **--fix**: suggest and apply corrections interactively
- **Default**: scan all skills authored by the user (`metadata.author` match)

## Step 1: Setup

1. Read `references/subagent-orchestration-best-practices.md` — defines the rules
2. Read `references/agent-skill-analyzer.md` — defines the per-skill analysis task

# Skill Prerequisite Check

Scan installed skills, discover their tool/MCP/auth dependencies via heuristic parsing, check if everything is installed and authenticated, and offer to fix issues interactively.

## When to Use

- Setting up a new machine
- After installing new skills
- Verifying environment is ready for all skills
- Debugging "tool not found" errors during skill execution

## Arguments

Parse from the user's invocation:

# Skill Spec Audit

Check installed skills against the [agentskills.io specification](https://agentskills.io/specification) and local conventions for metadata completeness.

## Arguments

- **Skill names**: tokens after the command -> filter to those skills only
- **--fix**: automatically add missing fields (prompts for values)
- **Default**: scan all non-symlinked skills in `~/.claude/skills/`

## Spec Requirements (agentskills.io)

| Field           | Required | Notes                                                          |
| --------------- | -------- | -------------------------------------------------------------- |

# CLI Consistency Review

Systematic review of a CLI tool's command interface to ensure consistent naming, conventions, and documentation alignment.

## Workflow

### Step 1: Inventory Commands

1. Run the CLI with `--help` or `-h` to get the top-level command list
2. For each subcommand, run `<cmd> <subcmd> --help` to get its full interface
3. Build an inventory table:

```
| Command       | Positional Args  | Flags              | Output Formats |

# Code Quality Scan

Systematic codebase scan that identifies duplication, redundancy, architectural issues, and improvement opportunities. Produces a prioritized action plan.

## Workflow

### Step 1: Scope Definition

Determine the scan scope:

- **Full repo**: Scan everything (default)
- **Directory**: Scan a specific package/module
- **Post-change**: Scan only files changed since last commit or compared to a branch

# New Tool Kickoff

A structured workflow for turning a tool idea into a working MVP. Covers the full cycle: research existing solutions, brainstorm approach, write a plan, scaffold the project, build core features, and write documentation.

## When to Use

- User says "I have an idea for a tool/CLI/library"
- User wants to start a new project from scratch
- User wants to research feasibility before building
- Greenfield development of a focused tool or CLI

## Workflow

### Phase 1: Research (Stop point: get user approval before Phase 2)

# Software Design Philosophies

Opinionated guidance on classic design principles and architectural patterns, with concrete code examples and trade-off analysis.

## When Applying Design Guidance

1. **Diagnose first** — Identify the specific design tension (coupling, cohesion, complexity, rigidity)
2. **Name the principle** — State which principle applies and why
3. **Show the trade-off** — Every principle has a cost; state it explicitly
4. **Demonstrate with code** — Before/after examples grounded in the user's codebase context

## Core Stance: Pragmatism Over Dogma

- Principles are heuristics, not laws. Apply them when they reduce complexity; skip them when they add it.

# Dependency PR Triage

End-to-end workflow for triaging dependency update PRs: list them, assess merge safety, and fix CI failures — all with maximum parallelism. Do NOT merge PRs unless the user explicitly asks.

## Phase 1: Discovery

List all open dependency update PRs. Detect the bot automatically (Renovate, Dependabot, etc.).

### Single repo

```bash
gh pr list --repo <owner/repo> --search "author:app/renovate OR author:app/dependabot" \
  --json number,title,author,mergeable,mergeStateStatus,statusCheckRollup,labels,updatedAt
```

# Issue Report

Investigate a bug, confirm it hasn't been reported, optionally verify in source code, and file a structured issue — all in one workflow.

## Arguments

- `/gh-issue-report` — interactive: asks for repo and bug description
- `/gh-issue-report <owner/repo> <description>` — uses arguments directly

## Phase 1: Intake

1. **Resolve target repo**:
   - If argument includes `owner/repo`, use it.
   - If the current directory is a git repo, offer it as default.

# GitHub Org Chart

Produces two artifacts in `${TMPDIR:-/tmp}/gh-org-chart/`:

- `<org>-org.json` — canonical data: teams, members (with role), repos (with `archived` flag and permission), CODEOWNERS paths. Cache + hand-editable source of truth.
- `<org>-org.html` — single self-contained interactive explorer rendered from the JSON. Opens via `file://`, works offline.

Set `OUT_DIR` once at the start of every phase and reuse it:

```bash
OUT_DIR="${TMPDIR:-/tmp}/gh-org-chart"
mkdir -p "$OUT_DIR"
```

# Go Version Bump

Batch workflow for bumping Go versions across multiple OSS repositories. Follows the three-phase pattern: discover and investigate, test locally, then create PRs — with user confirmation gates before every irreversible action.

## Step 1: Discover Go Repos and Latest Go Version

Run these two commands in parallel:

1. **List Go repos:**
   ```bash
   gh oss-watch list
   ```
   Filter to repos where the language column is "Go".

# OSS Release

Batch release workflow for multiple OSS repositories using `gh oss-watch releases`.

## Workflow

### Step 1: Check Release Status

Run `gh oss-watch releases` to identify repos with unreleased commits.

If all repos are up to date, report that and stop.

### Step 2: Analyze Unreleased Commits

# OSS Release Preparation

Systematic workflow to prepare a repository for open-source publishing. Covers code quality, licensing, documentation, CI, and release readiness.

## Key Principle: Convention Reuse

Before creating any file from scratch, check the user's sibling repositories for existing conventions. Users maintain consistency across their repos — reuse their LICENSE text, .golangci.yml, .gitignore, .github/workflows, .goreleaser.yaml, etc. from a recent, well-maintained repo.

**How to find conventions:**
1. Look at sibling directories (e.g., `ls ../`) for other repos by the same user
2. Pick a recently-updated repo with similar characteristics (same language, similar type)
3. Copy config files, adapting only what's project-specific (binary name, module path)

## Step 0: Classify the Project

# PR Review Triage

Triage your PR review queue into a single prioritized table. Combines a mechanical
decision tree (draft status, CI, reviewer assignment, staleness) with LLM judgment
(type classification, cognitive load estimation, priority narration) to produce an
opinionated ordering.

Includes team-assigned reviews by default. Use `--no-team` to show only PRs where
you are individually named as a reviewer.

## Phase 1: Discovery

Fetch all open PRs where review is requested from you (directly or via team membership).

# Conventional Commit

Create git commits that follow the Conventional Commits v1.0.0 specification.

## Workflow

### 1. Gather context

Run these in parallel:

```
git status
git diff --cached
git diff

# Meeting Scheduler

Find mutual availability and create Google Calendar events using the `gws` CLI.

## Prerequisites

- `gws` CLI installed and authenticated

## Workflow

### 1. Resolve attendee email

If the user provides a name but no email, search past calendar events:

# Activity Digest

Aggregate and summarize recent communication activity from Slack messages and meeting recordings (Fireflies). Produces a structured summary with action items, mentions, and key decisions.

## When to Use

- User asks for Slack activity summary
- User wants meeting highlights or action items
- User asks "what was discussed" or "what happened on Slack"
- User wants to find messages where they were mentioned
- Producing communication portions of a daily/weekly report

## Prerequisites

# Blog Post Mining

<!-- skillctx:begin -->
## Setup
Locate this skill's directory (the folder containing this SKILL.md), then run the
resolver script from there:

```bash
python <skill-dir>/scripts/skillctx-resolve.py resolve p-blog-post-mining
```

The resolver outputs each binding as `key: value` (one per line). Substitute each `{binding_key}` placeholder below with the resolved value.

If any values are missing or the user requests changes, use:

# Blog Writer

<!-- skillctx:begin -->
## Setup
Locate this skill's directory (the folder containing this SKILL.md), then run the
resolver script from there:

```bash
python <skill-dir>/scripts/skillctx-resolve.py resolve p-blog-writer
```

The resolver outputs each binding as `key: value` (one per line). Substitute each `{binding_key}` placeholder below with the resolved value.

If any values are missing or the user requests changes, use:

# Clipboard Copy

Copy several useful fragments from this session into clipboard history at once,
each as its own entry, each containing only the part worth pasting.

The user has a clipboard history manager, so copying 3-6 items is cheap and
useful. The value of this skill is **extraction quality**, not volume: a command
without its `$` prompt, a path without the prose around it, a query without the
explanation. Never copy a whole assistant message — that is what the built-in
`/copy` is for.

## Arguments

- **`[hint]`** — free text narrowing what to grab: `/p-clipboard-copy the sql and the pod name`.

# Daily Reflection

<!-- skillctx:begin -->
## Setup
Locate this skill's directory (the folder containing this SKILL.md), then run the
resolver script from there:

```bash
python <skill-dir>/scripts/skillctx-resolve.py resolve p-daily-reflection
```

The resolver outputs each binding as `key: value` (one per line). Substitute each `{binding_key}` placeholder below with the resolved value.

If any values are missing or the user requests changes, use:

# Daily Report Generator

<!-- skillctx:begin -->
## Setup
Locate this skill's directory (the folder containing this SKILL.md), then run the
resolver script from there:

```bash
python <skill-dir>/scripts/skillctx-resolve.py resolve p-daily-report
```

The resolver outputs each binding as `key: value` (one per line). Substitute each `{binding_key}` placeholder below with the resolved value.

If any values are missing or the user requests changes, use:

# Daily Standup

<!-- skillctx:begin -->
## Setup
Locate this skill's directory (the folder containing this SKILL.md), then run the
resolver script from there:

```bash
python <skill-dir>/scripts/skillctx-resolve.py resolve p-daily-standup
```

The resolver outputs each binding as `key: value` (one per line). Substitute each `{binding_key}` placeholder below with the resolved value.

If any values are missing or the user requests changes, use:

# Egosearch

<!-- skillctx:begin -->
## Setup
Locate this skill's directory (the folder containing this SKILL.md), then run the
resolver script from there:

```
python <skill-dir>/scripts/skillctx-resolve.py resolve p-ego-search
```

The resolver outputs each binding as `key: value` (one per line).
For list values, it outputs JSON (e.g., `orgs: ["acme", "widgets-inc"]`).
Substitute each `{binding_key}` placeholder below with the resolved value.

# p-md-to-slides

Convert a Markdown deck source into a styled Google Slides presentation, with a chosen design theme and speaker notes pushed from the source.

## When to use

- The user has a `slide.md` (or similar) with `## Slide N — title` sections and wants Google Slides
- The user is preparing a talk / LT / conference presentation and has drafted the content in Markdown
- The user asks to convert / build / generate slides from a Markdown source

Not for activity-driven decks (see `o-tailor-allhands-deck` for those) — this is for hand-authored Markdown → Google Slides.

## Prerequisites

# Meeting Prep

<!-- skillctx:begin -->
## Setup
Locate this skill's directory (the folder containing this SKILL.md), then run the
resolver script from there:

```bash
python <skill-dir>/scripts/skillctx-resolve.py resolve p-meeting-prep
```

The resolver outputs each binding as `key: value` (one per line). Substitute each `{binding_key}` placeholder below with the resolved value.

If any values are missing or the user requests changes, use:

# News Briefing

<!-- skillctx:begin -->
## Setup
Locate this skill's directory (the folder containing this SKILL.md), then run the
resolver script from there:

```bash
python <skill-dir>/scripts/skillctx-resolve.py resolve p-news-briefing
```

The resolver outputs each binding as `key: value` (one per line). Substitute each `{binding_key}` placeholder below with the resolved value.

If any values are missing or the user requests changes, use:

# Slack Triage

Scan Slack for messages needing attention, classify them by action type, present a prioritized summary, and help draft/send replies for items you select.

## When to Use

- User asks to triage or check Slack
- User wants to know what needs their attention
- User wants help drafting Slack replies
- User says "what did I miss on Slack"

## Arguments

Parse from the user's invocation message:

# Violentmonkey Userscript Sync

Violentmonkey's cloud sync folder holds the editable copy of every userscript.
Editing the code there is only half the job.

`vmscript.py` locates the folder itself: `--dir` wins, then `$VM_SYNC_DIR`, then
the known Dropbox / OneDrive / Google Drive layouts. Never hard-code the path —
if detection fails the script says so and lists what it tried.

## The failure mode

Violentmonkey decides what to pull by comparing timestamps, not content. If you
change a script's `code` but leave the timestamps alone, the browser sees "no
change", keeps its own copy, and **pushes the old code back over your edit** on

# Project Namer

## Overview

Guide users from vague naming requirements to a memorable, unique name through structured exploration of scope, constraints, and style preferences.

## When to Use

- Naming a new repository, project, tool, or product
- User is unsure what to call something
- User rejects initial suggestions as "too generic" or "too vendor-specific"

## Core Workflow

# Restaurant Search

Find Japanese restaurants using the `hpp` CLI (HotPepper Gourmet API).
https://github.com/jackchuka/hpp

## Prerequisites

- `hpp` CLI installed and `HOTPEPPER_API_KEY` env var set

## Workflow

### 1. Parse the request

Extract from the user's request: