org-agent-skill-creator
Scaffold and validate scope-aware agent skills (company, enterprise, org, team, project, application). Use when the user asks to create a new agent skill, generate a SKILL.md file, scaffold a skill directory, or validate that existing skill directories meet SKILL_SPEC.md (frontmatter, naming rules, structure, scope/tier).
- License 许可
- MIT
- 最近更新
- 2026-08-25
- Stars
- ★ 0
- Forks
- 0
01 前言 Front Matter
- name
- org-agent-skill-creator
- tier
- org
- description
- Scaffold and validate scope-aware agent skills (company, enterprise, org, team, project, application). Use when the user asks to create a new agent skill, generate a SKILL.md file, scaffold a skill directory, or validate that existing skill directories meet SKILL_SPEC.md (frontmatter, naming rules, structure, scope/tier).
03 SKILL.md 正文
Agent Skill Creator (Scope-Aware)
Scaffold a new agent skill OR validate an existing one against SKILL_SPEC.md. Every skill is scoped to one of six tiers — each tier owns a distinct slice of knowledge/context — and the scope is encoded in both the directory-name prefix and the tier: frontmatter field.
This skill mirrors the slash commands /agent-skill-create and /agent-skill-validate. Use it when slash commands are not auto-loaded or when the user invokes the skill explicitly.
Mode Selection
Pick a mode based on the user's request:
- create — user wants to make a new skill ("create a skill", "scaffold a new skill", "new agent skill")
- validate — user wants to check existing skills ("validate skill X", "check if this skill meets the spec", "audit skills")
If ambiguous, ask the user which mode before proceeding.
Scope Tiers
Every skill belongs to exactly one scope. The scope determines what kind of knowledge/context the skill encodes, the directory-name prefix, and the tier: frontmatter value.
| Scope | Prefix | tier: value |
Knowledge / context the skill owns |
|---|---|---|---|
| company | company- |
company |
Company-wide policy, brand, legal/compliance baselines, security floor, code-of-conduct. Applies to every employee and every codebase the company touches. |
| enterprise | enterprise- |
enterprise |
Multi-org / multi-division standards: shared platforms, cross-BU governance, procurement-approved tooling, enterprise architecture patterns. Sits above org but below company. |
| org | org- |
org |
Engineering-org or business-unit standards: shared workflows, common tooling choices, on-call/release norms, naming conventions, repo-template policy. |
| team | team- |
team |
Team-level conventions: tech-stack picks, coding style, review checklist, on-call rotation, sprint cadence. Specific to one squad/team. |
| project | project- |
project |
Project-specific architecture, build/test pipeline, dependency graph, domain language, milestone plan. Bound to one repo or coordinated set of repos. |
| application | app- |
application |
Application-runtime concerns: deployed surfaces, integration points, env-config, observability, customer-facing behavior. Bound to one running service or product. |
Note: application uses the historical app- prefix to stay backwards-compatible with existing skills (e.g. app-plan-feature-stories). Do not introduce application- as a prefix.
Scope decision questions
When the user is unsure which scope to pick, ask:
- Who is the audience? Every employee → company. Multiple orgs/BUs → enterprise. One org → org. One team → team. One repo → project. One running service → application.
- Where does the knowledge live today? Legal/policy site → company. Enterprise wiki / architecture council → enterprise. Org handbook → org. Team README → team. Repo docs → project. Runbook / service dashboard → application.
- If this knowledge were wrong, who would file the bug? Picks the owning scope.
Create Mode
Input
Expected args: <skill-name> or <skill-name> <short description>.
- If only a name is given, ask for a description before proceeding.
- If empty, ask for a name, scope, and description.
Step 1: Ask the user which scope to create
Always ask which scope the new skill belongs to. Present the six options with their one-line knowledge/context summaries (from the table above) so the user can pick deliberately. If the user names a scope that isn't in the table, push back and offer the closest match — do not invent a seventh tier.
Map the chosen scope to its <prefix> and <tier> for use in Steps 2–5.
Step 2: Validate the Skill Name
Check against SKILL_SPEC Section 3.1:
- 1–64 characters
- Lowercase alphanumeric (
a-z,0-9) and hyphens (-) only - Cannot start or end with a hyphen
- Cannot contain consecutive hyphens (
--)
Scope-prefix rule: the final directory name must begin with the chosen scope's prefix (e.g. team-onboarding-checklist, project-ployglot-release-flow). If the user-provided name lacks the prefix, prepend it automatically and show the corrected name back to the user for confirmation.
If the name is invalid for any other reason, explain why and suggest a corrected version. Do not proceed until valid.
Step 3: Determine Skill Location
The skill directory should be created as a sibling of other skill directories under .agents/skills/. Confirm the target path with the user:
.agents/skills/<prefix><skill-stem>/
Step 4: Gather Skill Details
Ask the user (if not provided):
- Description (required) — what it does and when to trigger it
- Knowledge / context payload — what scope-specific knowledge this skill carries (the answer should reflect the chosen tier — e.g. a
team-skill should reference team artifacts, not company policy) - Instructions — step-by-step body content for the agent
- Optional directories —
scripts/,references/,assets/ - Optional frontmatter —
license,compatibility,metadata,allowed-tools
Step 5: Create the Directory Structure
<prefix><skill-stem>/
├── SKILL.md
├── scripts/ # only if requested
├── references/ # only if requested
└── assets/ # only if requested
Step 6: Generate SKILL.md
---
name: <prefix><skill-stem>
description: <description>
tier: <tier>
---
# <Skill Title>
<Body: scope-specific knowledge, instructions, examples, edge cases>
Include any optional frontmatter the user specified. Keep the body under 500 lines. The body should make the scope explicit — a tier: team skill should not silently embed company-wide policy, and a tier: company skill should not encode one team's tech stack.
Step 7: Validate
Run the validate mode mentally against the new skill (including the new tier check in Step 2 below) and report any issues.
Output
## Created: <skill-name>
Scope: <tier> (<one-line knowledge/context summary>)
Location: <full-path>
### Structure
<tree output>
### SKILL.md Preview
<first 20 lines>
Status: All validation checks passed.
Validate Mode
Input
Expected args: path to a skill directory, OR empty / . to scan .agents/skills/ for all skill directories (any directory containing SKILL.md).
Step 1: Structural Validation
- [ ] Skill directory exists
- [ ]
SKILL.mdfile exists inside
Step 2: Frontmatter Validation
Parse the YAML frontmatter block (between --- delimiters) and check:
Required:
- [ ]
nameexists and is 1–64 characters - [ ]
nameuses only lowercase alphanumeric (a-z,0-9) and hyphens (-) - [ ]
namedoes not start or end with a hyphen - [ ]
namedoes not contain consecutive hyphens (--) - [ ]
nameexactly matches the parent directory name - [ ]
descriptionexists, is non-empty, and is 1–1024 characters - [ ]
tierexists and is one of:company,enterprise,org,team,project,application - [ ]
tiermatches the directory-name prefix per the scope table (company-→company,enterprise-→enterprise,org-→org,team-→team,project-→project,app-→application)
Optional (if present):
- [ ]
license— short string - [ ]
compatibility— max 500 characters - [ ]
metadata— string-to-string key-value map - [ ]
allowed-tools— space-delimited string
Step 3: Body Content Validation
- [ ] Markdown body exists after the frontmatter
- [ ] Body is under 500 lines (warn if exceeded)
- [ ] File references use relative paths (no absolute paths like
/foo/bar) - [ ] Body content is consistent with the declared
tier(warn if atier: teamskill encodes obvious company-wide policy, or vice versa)
Step 4: Optional Directory Checks
If present, verify non-empty:
- [ ]
scripts/— executable or recognized script extensions - [ ]
references/—.mdor documentation files - [ ]
assets/— resource files
Output
## Validation: <skill-name>
Scope: <tier>
Status: PASS | FAIL | WARN
### Results
- [x] Check that passed
- [ ] Check that failed — reason
### Summary
X/Y checks passed. Z warnings.
For multiple skills, append a summary table:
| Skill | Scope | Status | Passed | Warnings | Errors |
|-------|-------|--------|--------|----------|--------|
Reference
Full spec: SKILL_SPEC.md at the repo root.
Source commands: .agents/commands/agent-skill-create.md, .agents/commands/agent-skill-validate.md.
04 同仓库更多 Skills
validation_handoff
Forces the agent to conclude its response by generating a strict validation checklist and outlining pending actions, focusing heavily on defensive execution and edge-case testing.
project-ployglot-project-scafford
Scaffold a polyglot library project as TypeScript + Python twin packages under `packages/ts/` + `packages/py/`, with a shared `SPEC.md`, cross-language `tests/parity/fixtures.json`, side-by-side `examples/sdk/` + `examples/api/` documentation, per-package `Makefile`, and a root orchestrator that exposes `make ci`. Open-source friendly — no organization-specific paths or scopes baked in. Use when starting a new polyglot library, porting a single-language library to a twin, or auditing/regularizing an existing two-language repo against the canonical layout.
playwright-ui-locator
Auto-heal Playwright tests after a frontend developer changes a div's class, id, or other selector. Catches a failing Playwright test, captures the old vs new DOM tree, finds the element that drifted, derives the most stable replacement locator, and proposes the fix as a GitHub pull request (confident heals) or files a GitHub issue (ambiguous / element-removed cases) — never editing the working tree directly. Trigger when Playwright tests fail with "locator resolved to 0 elements", "Timeout waiting for selector", or after a UI refactor / class rename / Tailwind cleanup broke previously-passing tests.
org-learn-context-window
Distill the current conversation into a reusable command or skill artifact. Use when the user wants to capture a workflow they just executed (create a reusable slash command) or formalize a resolution/mistake/correction into a reusable skill so the same class of issue never recurs.
app-workshop-session-pdf-recap-next
Extract content from a workshop session PDF and produce a structured recap focused on (1) what was learned, (2) next steps, and (3) possible enhancements. Ingests a single PDF file path, parses session material (slides, transcripts, exercises, Q&A), and emits a Markdown report with Learning Recap, Next Steps, and Enhancement Opportunities sections with page-level traceability. Use when the user asks to "summarize a workshop", "recap a training PDF", "pull next steps from a session deck", or provides a workshop/seminar/tutorial PDF and wants a learn-and-act summary.
app-workshop-recaps-consolidate
Consolidate multiple workshop-session recap Markdown files (typically produced by the workshop-session-pdf-recap-next skill) into a single unified report. Merges and deduplicates learnings across sessions and emits six sections — Consolidated Recap, Follow-ups, Action Items, Next Steps, Possible Enhancements, and Industry / External Viewpoint. The last section supplements the attendees' material with current external perspective via web research. Use when the user has a set of per-session recap files and wants one portfolio-level summary with an outside-in lens ("consolidate these recaps", "merge my workshop notes", "cross-session summary", "roll up action items").