GitHub - jiunbae/agent-skills

Quickstart • Skills • Personas • Hooks • Install • Contributing
한국어

What is this?

A collection of skills, personas, and hooks for AI coding agents (Claude Code, Codex CLI, Gemini CLI). Each skill is a self-contained markdown module that gives an agent domain-specific capabilities.

CLI tool: Install and manage skills with agt — npm install -g @open330/agt or just npx @open330/agt

This repository is the single source of truth for skill content. The Rust CLI, npm packages, and platform releases are maintained only in Open330/agt.

Quickstart for Agents

Install the agent-skills toolkit into this project:

1. Install the "core" profile globally for Claude Code:
   npx @open330/agt skill install --profile core --from jiunbae/agent-skills --global

2. Install the same profile globally for Codex:
   npx @open330/agt skill install --profile core --from jiunbae/agent-skills --global --agent codex

3. Install all available personas globally:
   npx @open330/agt persona install --global --from jiunbae/agent-skills

4. Verify installation:
   npx @open330/agt skill list
   npx @open330/agt skill list --agent codex
   npx @open330/agt persona list

5. Optional — the "core" profile does not include `agents/air-workbench`.
   Install that one explicitly only if you want the local graph workbench:
   npx @open330/agt skill install --from jiunbae/agent-skills/agents/air-workbench --global

Note: Use `npm install -g @open330/agt` first if you prefer running `agt` directly.

Slowstart for Humans

With npx (No Install)

npx @open330/agt skill install --profile core --from jiunbae/agent-skills
npx @open330/agt skill install --profile core --from jiunbae/agent-skills --agent codex
npx @open330/agt skill install -g --from jiunbae/agent-skills  # Browse & install from repo
npx @open330/agt persona install -g --from jiunbae/agent-skills

With agt CLI (Global Install)

npm install -g @open330/agt
agt skill install --profile core --from jiunbae/agent-skills
agt skill install --profile core --from jiunbae/agent-skills --agent codex
agt skill install -g --from jiunbae/agent-skills/development/git-commit-pr
agt persona install -g --from jiunbae/agent-skills

--agent claude is the default and installs to .claude/skills/<skill>. --agent codex installs to .agents/skills/<skill>. Add --global for the corresponding user-level directory. Skills an older agt placed under <group>/<skill> are not loaded by Claude Code. agt releases after 2026.7.23 add --claude-dir (or CLAUDE_CONFIG_DIR) to pick another config directory and agt skill migrate --global to move grouped installs.

With install.sh

git clone https://github.com/jiunbae/agent-skills ~/.agent-skills
cd ~/.agent-skills

./install.sh --core                    # Core skills only
./install.sh --core --codex            # Core skills + Codex user skill links
./install.sh --core --hooks            # Core + hooks
./install.sh all --link-static --codex # Everything
./install.sh --list                    # List available options

Install Options

Option	Description
`--core`	Install core skills globally (recommended)
`--cli`	Install the published `@open330/agt` CLI plus legacy compatibility commands
`--link-static`	Link each `static/*` item under `~/.agents` while preserving `~/.agents/skills`
`--codex`	Link selected skills individually into `~/.agents/skills` without replacing Codex system skills (also links `static/*` items under `~/.agents`)
`--hooks`	Install Claude Code hooks
`--personas`	Install agent personas
`--copy`	Copy instead of symlink
`--dry-run`	Preview only
`--uninstall`	Remove installed skills

Core Skills

Installed by default with --core:

development/git-commit-pr — Git commit & PR guide
context/static-index — Global static context index
security/security-auditor — Repository security audit
agents/background-implementer — Isolated parallel implementation with verified integration
agents/background-planner — Parallel persona planning with stance-steered synthesis
agents/background-reviewer — Parallel persona review with adversarial verification
agents/rpf — Pointer-driven iterative review, plan, work, and feedback

Skill Naming

A Skill's name frontmatter must equal its directory name. A host lists a Skill by its directory, so any other declared name is a second name nobody can type, and catalog items are keyed on the frontmatter name, which makes the divergence observable rather than cosmetic. agents/air-workbench enforces this in tests/core.test.mjs.

Opt-in Skills (not in `core`)

Every other skill in the catalog is installed on request. agents/air-workbench is deliberately one of them: it ships a local HTTP server, a checked-in browser bundle, and an approval-gated native-run path, so it stays opt-in rather than being added to every workspace by default. Nothing in --profile core or --core installs it. Pick whichever path you already use:

# npx
npx @open330/agt skill install --from jiunbae/agent-skills/agents/air-workbench --global

# agt CLI
agt skill install -g --from jiunbae/agent-skills/agents/air-workbench

# install.sh, from a repository checkout
./install.sh agents/air-workbench

Then run it from the installed copy — it needs no npm install:

node ~/.claude/skills/air-workbench/scripts/air.mjs workbench

The same form works for any other catalog entry, for example --from jiunbae/agent-skills/development/playwright or ./install.sh integrations/slack-skill.

Skills Catalog

🤖 agents/ — AI Agents

Skill	Description
`background-implementer`	Isolated parallel implementation (worktrees) with pre-integration verification
`background-planner`	Bounded parallel planning with planner personas and stance-steered synthesis
`background-reviewer`	Bounded parallel persona review with adversarial verification and root-cause merge
`incident-writer`	Structured incident and status-page reports
`rpf`	Explicit pointer-driven multi-agent review, plan, work, and feedback loop
`air-workbench`	AIR Skill workflow editing, local Skill discovery, plan approval, and observable tracing

🛠 development/ — Dev Tools

Skill	Description
`appstore-screenshots`	App Store screenshot capture/upload and authenticated ASC inspection
`context-worktree`	Auto git worktree per task
`git-commit-pr`	Git commit & PR generation guide
`grill-me`	Adversarial plan questioning before implementation
`iac-deploy-prep`	IaC deployment prep (K8s, Dockerfile, CI/CD)
`playwright`	Playwright browser automation

📊 business/ — Business

Skill	Description
`bm-analyzer`	Business model analysis & monetization strategy
`proposal-analyzer`	Proposal / RFP analysis

🔗 integrations/ — Integrations

Skill	Description
`discord-skill`	Discord REST API
`notion-summary`	Notion page upload
`obsidian-tasks`	Obsidian TaskManager (Kanban, Dataview)
`obsidian-writer`	Obsidian Vault writing and docs.jiun.dev publishing
`service-manager`	Docker container & service management
`slack-skill`	Slack app development & API
`vault-secrets`	Vaultwarden credentials & API key management

🧠 ml/ — ML/AI

Skill	Description
`audio-processor`	ffmpeg-based audio processing
`ml-benchmark`	ML model benchmarking
`model-sync`	Model file server sync
`triton-deploy`	Triton Inference Server deployment

🔐 security/ — Security

Skill	Description
`security-auditor`	Repository security audit

📁 context/ — Context Management

Skill	Description
`static-index`	Global static context index with user profile

🔧 meta/ — Meta Skills

Skill	Description
`skill-manager`	Skill ecosystem management

✍️ common/ — Writing

Skill	Description
`korean-editor`	Conservative Korean copy editing with fidelity checks

Personas

Expert identities as markdown files — usable with any AI agent.

Persona	Role	Domain
`security-reviewer`	Senior AppSec Engineer	OWASP, auth, injection
`architecture-reviewer`	Principal Architect	SOLID, API design, coupling
`code-quality-reviewer`	Staff Engineer	Readability, complexity, DRY
`performance-reviewer`	Performance Engineer	Memory, CPU, I/O, scalability
`database-reviewer`	Senior DBA	Query optimization, schema, indexing
`frontend-reviewer`	Senior Frontend Engineer	React, accessibility, performance
`devops-reviewer`	Senior DevOps/SRE	K8s, IaC, CI/CD

Above is a featured subset. Planning personas (type: planning) — technical-planner, product-planner, delivery-risk-planner — drive background-planner. Full library: personas/README.md.

Using with agt CLI

agt persona review security-reviewer --codex
agt persona review security-reviewer --codex "is this architecture scalable?"
agt persona install -g --all
agt persona show security-reviewer

Using Directly

Personas are just .md files. Any agent that can read a file can adopt a persona:

cat personas/security-reviewer.md | codex -q "Review this code"
cat personas/security-reviewer.md   # pipe to any AI agent

.agents/personas/security-reviewer.md    ← project local (highest priority)
~/.agents/personas/security-reviewer.md  ← user global
personas/security-reviewer.md            ← library (bundled)

Hooks

Event-driven automation for Claude Code.

./install.sh --hooks

Hook	Event	Description
`english-coach`	`UserPromptSubmit`	Rewrites prompts in natural English with vocabulary
`prompt-logger`	`UserPromptSubmit`	Captures each submitted prompt into omp in the background
`stop-capture`	`Stop`	Captures each completed response into omp in the background

Creating Your Own Skills Repo

You can create your own skills repository with the same structure as this one. agt will discover it automatically.

Directory Structure

my-skills/
├── agents/                    # Group: AI agent skills
│   └── my-agent/
│       └── SKILL.md           # Required
├── development/               # Group: dev tools
│   └── my-tool/
│       ├── SKILL.md           # Required
│       ├── scripts/           # Optional: helper scripts
│       └── templates/         # Optional: templates
├── personas/                  # Personas directory
│   ├── my-reviewer/
│   │   └── PERSONA.md
│   └── my-expert.md           # Single-file persona also works
├── profiles.yml               # Optional: installation profiles
└── README.md

SKILL.md Format

---
name: my-skill-name
description: "What this skill does, when it should trigger, and when it should not. Use for 'keyword1' and 'keyword2' requests."
---

# Skill Title

## Quick Start

\`\`\`bash
command --example
\`\`\`

## Workflow

Step-by-step instructions for the AI agent...

## Best Practices

**DO:**
- Follow this pattern

**DON'T:**
- Avoid this anti-pattern

Field	Required	Description
`name`	Yes	Skill identifier (kebab-case)
`description`	Yes	What the skill does, trigger terms, scope, and important non-trigger boundaries

Keep the portable frontmatter baseline to name and description. Put Codex UI metadata, tool dependencies, and implicit-invocation policy in agents/openai.yaml. Add host-specific frontmatter only when that host's current validator explicitly supports it.

PERSONA.md Format

---
name: my-reviewer
role: "Senior Engineer — Domain Expert"
domain: security
type: review
tags: [security, owasp, auth]
---

# My Reviewer

## Identity

Background, expertise, and review philosophy...

## Review Lens

When reviewing, evaluate:
1. Security vulnerabilities
2. Best practice adherence
...

## Output Format

### Findings
#### [SEVERITY] Finding Title
- **File**: path:line
- **Impact**: Description
- **Recommendation**: Fix

Field	Required	Description
`name`	Yes	Persona identifier (kebab-case)
`role`	Yes	Job title / expert role
`domain`	Yes	Expertise domain
`type`	Yes	Usually `review`
`tags`	Yes	Relevant focus areas

profiles.yml Format

core:
  description: "Essential skills for every workspace"
  skills:                          # Explicit skill paths
    - development/git-commit-pr
    - context/static-index
  groups:                          # Include entire groups
    - agents

dev:
  description: "Development workflow tools"
  groups:
    - development

Test & Install

# Point agt to your repo
export AGT_DIR=~/my-skills
# Or clone to the default location
git clone https://github.com/you/my-skills ~/.agent-skills

agt skill list                     # Verify skills discovered
agt skill install my-skill -g      # Install globally
agt skill install --profile core   # Install a profile
agt persona install my-reviewer    # Install a persona

# Others can install from your repo directly
agt skill install --from you/my-skills
agt persona install --from you/my-skills

Create with AI (Prompts)

Copy-paste these prompts to create skills and personas with any AI agent.

Create a Skill

Prompt: Create a new skill

Create a new skill for the agent-skills repository.

Skill name: [YOUR_SKILL_NAME]
Group: [GROUP_NAME] (e.g., development, integrations, agents, ml, security)
Description: [WHAT_THE_SKILL_DOES]

Create the file at [GROUP]/[SKILL_NAME]/SKILL.md with this structure:

1. YAML frontmatter with only `name` and `description`; include English/Korean trigger
   terms and important non-trigger boundaries in the description
2. A "Quick Start" section with 2-3 essential commands/examples
3. A "Workflow" section with step-by-step instructions
4. A "Best Practices" section with DO/DON'T guidelines

Rules:
- Description should be third person and state what the skill does, when to use it, and when not to
- Keep under 300 lines total
- Code examples should be practical and production-ready
- Include both English and Korean trigger keywords where relevant
- Focus on what the AI agent should DO, not theory

Reference this existing skill for style:
---
name: git-commit-pr
description: "Guides local Git commit preparation and PR drafting with security checks. Use for commit, PR, pull request, and 커밋 requests."
---

Create a Persona

Prompt: Create a review persona

Create a new code review persona for the agent-skills repository.

Persona name: [YOUR_PERSONA_NAME]-reviewer
Domain: [DOMAIN] (e.g., security, architecture, performance, database, frontend, devops)
Role: [JOB_TITLE]

Create the file at personas/[PERSONA_NAME]/PERSONA.md with this structure:

1. YAML frontmatter with: name, role, domain, type (review), tags
2. "Identity" section: background, expertise (5+ bullet points), attitude (2-3 sentences)
3. "Review Lens" section: numbered list of what they evaluate
4. "Evaluation Framework" section: table with Category, Severity (CRITICAL/HIGH/MEDIUM/LOW), Criteria
5. "Output Format" section: markdown template for review output
6. "Red Flags" section: concrete patterns the reviewer flags whenever they appear
7. "Key Principles" section: numbered guiding principles

Rules:
- The persona should be opinionated and have a clear point of view
- Include specific technologies/frameworks in their expertise
- Red flags should be concrete, not generic
- Output format should include: Summary, Findings (with severity), Positive Observations
- Keep under 200 lines

Reference this existing persona for style:
---
name: security-reviewer
role: "Senior Application Security Engineer"
domain: security
type: review
tags: [security, owasp, auth, injection, xss, ssrf]
---

Create a Profile

Prompt: Create an installation profile

Create a new installation profile for the agent-skills repository.

Profile name: [PROFILE_NAME]
Purpose: [WHO_IS_THIS_FOR]
Available groups: agents, development, business, integrations, ml, security, context, meta, common

Add the profile to profiles.yml with:
- description: one-line description of the profile
- skills: list of specific group/skill-name paths to include (optional)
- groups: list of group names to include all skills from (optional)

You can mix both "skills" (specific picks) and "groups" (entire categories).

Example:
```yaml
backend:
  description: "Backend development essentials"
  skills:
    - security/security-auditor
  groups:
    - development
    - integrations

Keep profiles focused — a profile with everything is just "full" or "all".


</details>

### Create a Complete Skills Repo

<details>
<summary><b>Prompt: Bootstrap a new skills repository</b></summary>

Create a new agent-skills repository with the following structure. This repo will be discoverable by the agt CLI tool (https://github.com/open330/agt).

Repository purpose: [YOUR_PURPOSE] Skills to include: [LIST_OF_SKILLS] Personas to include: [LIST_OF_PERSONAS]

Create the following structure:

Group directories (e.g., development/, integrations/) containing skill subdirectories
Each skill has a SKILL.md with portable YAML frontmatter (name and description) and concise Markdown instructions; use agents/openai.yaml for Codex UI metadata, dependency declarations, or implicit-invocation policy
A personas/ directory with PERSONA.md files for each persona
A profiles.yml defining installation profiles (core, dev, full at minimum)
A README.md documenting the repository

Requirements:

Skills are organized by group: each group is a directory, each skill is a subdirectory
A valid skill must have SKILL.md in its directory
A valid persona must have PERSONA.md (in a directory or as a standalone .md file)
profiles.yml uses "skills" (explicit paths) and/or "groups" (entire categories)
The "all" profile is built-in to agt, no need to define it

Users install with: git clone https://github.com/you/repo ~/.agent-skills agt skill install --profile core -g agt persona install --all -g


</details>

---

## Architecture

agent-skills/ open330/agt (CLI tool) ├── agents/ AI agent skills ├── agt/ Rust CLI ├── development/ Dev tool skills ├── npm/ npm packaging ├── business/ Business skills ├── setup.sh Installer ├── integrations/ Integration skills └── assets/ Branding ├── ml/ ML/AI skills ├── security/ Security skills ├── context/ Context management ├── meta/ Meta skills ├── common/ Writing skills ├── personas/ Expert personas ├── hooks/ Claude Code hooks ├── static/ Global context ├── install.sh Local installer └── codex-support/ Codex CLI


---

## Contributing

1. **Add a skill** — Create a new skill in the appropriate category
2. **Add a persona** — Create a domain expert persona
3. **Improve docs** — Fix typos, add examples, translate
4. **Report issues** — Bug reports and feature requests welcome

```bash
git clone https://github.com/jiunbae/agent-skills ~/.agent-skills
cd ~/.agent-skills
./install.sh --core

For CLI tool contributions, see open330/agt.

License

MIT License. See LICENSE, which also records the third-party work some skills are adapted from.

_{31 skills | 20 personas | 3 hooks}
_{CLI tool: open330/agt}

Name		Name	Last commit message	Last commit date
.github/workflows		.github/workflows
agents		agents
assets		assets
business		business
cli		cli
codex-support		codex-support
common/korean-editor		common/korean-editor
context/static-index		context/static-index
development		development
hooks		hooks
integrations		integrations
meta/skill-manager		meta/skill-manager
ml		ml
personas		personas
security/security-auditor		security/security-auditor
static		static
.gitignore		.gitignore
CHANGELOG.md		CHANGELOG.md
LICENSE		LICENSE
MIGRATION.md		MIGRATION.md
README.md		README.md
README_ko.md		README_ko.md
agt.toml		agt.toml
install.cmd		install.cmd
install.ps1		install.ps1
install.sh		install.sh
profiles.yml		profiles.yml
setup.sh		setup.sh

Latest commit

History

Folders and files

Repository files navigation