Stage, draft, and execute a conventional commit. Use this command when you want to commit changes at any point in your workflow — after writing plan docs, mid-TDD, after fixing review findings, or any ad-hoc change. Inspects git state, helps you decide what to stage, drafts a conventional commit message with type, optional task scope, and description, then executes after your confirmation.
Generate conventional commit messages for the Shopware AI Coding Tools marketplace. Determines type, infers scope from plugin directory structure, and detects breaking changes. Use when generating commit messages in this repository.
This skill should be used when the user asks to 'commit', 'create a commit', or 'git commit'. It creates conventional commits with FQCN scopes for Ansible collection content (roles, modules, plugins).
Create a well-formed git commit from current changes using session history for rationale and summary; use when asked to commit, prepare a commit message, or finalize staged work. --- # Commit ## Goals - Produce a commit that reflects the actual code changes and the session context. - Follow common git conventions (type prefix, short subject, wrapped body). - Include both summary and rationale in the body. ## Inputs - Codex session history for intent and rationale. - `git status`, `git diff`, and `git diff --staged` for actual changes. - Repo-specific commit conventions if documented. ## Steps 1. Read session history to identify scope, intent, and rationale. 2. Inspect the working tree and staged changes (`git status`, `git diff`, `git diff --staged`). 3. Stage intended changes, including new files (`git add -A`) after confirming scope. 4. Sanity-check newly added files; if anything looks random or likely ignored (build artifacts, logs, temp files), flag it to the user before committing. 5. If staging is incomplete or includes unrelated files, fix the index or ask for confirmation. 6. Choose a conventional type and optional scope that match the change (e.g., `feat(scope): ...`, `fix(scope): ...`, `refactor(scope): ...`). 7. Write a subject line in imperative mood, <= 72 characters, no trailing period. 8. Write a body that includes: - Summary of key changes (what changed). - Rationale and trade-offs (why it changed). - Tests or validation run (or explicit note if not run). 9. Append a `Co-authored-by` trailer for Codex using `Codex <[email protected]>` unless the user explicitly requests a different identity. 10. Wrap body lines at 72 characters. 11. Create the commit message with a here-doc or temp file and use `git commit -F <file>` so newlines are literal (avoid `-m` with `\n`). 12. Commit only when the message matches the staged changes: if the staged diff includes unrelated files or the message describes work that isn't staged, fix the index or revise the message
Use when preparing to commit changes or drafting a git commit message in this repo. --- # Git Commit & Commit Message (SignNow MCP Server) ## Critical rules * **NEVER commit directly to `main` or `master`.** Always work on a dedicated branch. * Do not commit unless **all required checks** pass (see below). * Keep each commit **one logical change** (single change type). * Commit message follows **Conventional Commits**. ## Workflow 0. **Create (or switch to) a feature branch — MANDATORY** * NEVER commit to `main` or `master` directly. * If not already on a feature branch, create one: * `git checkout -b <type>/<short-description>` (e.g., `feat/add-embedded-editor`, `fix/token-refresh`) * Branch naming: `<type>/<short-description>` using the same type vocabulary as commit types. 1. **Check what changed** * `git status -sb` * If changes are mixed, split into separate commits using `git add -p`. 2. **Review staged diff** * Stage what belongs to this commit. * Inspect: `git diff --cached` 3. **Run required checks (must be green)** ```bash pytest tests/unit/ -v ruff check src/ tests/ ruff format --check src/ tests/ ``` * If any command fails, fix the issue and rerun **all** checks. 4. **Compose the commit message** ### Subject format `<type>(<scope>)?: <subject>` ### Subject rules * Imperative mood ("Add", "Fix", "Remove", "Prevent", ...) * No trailing period * Prefer **≤ 72 chars** ### Body (optional) * Explain **why**, not just what. * Wrap lines at ~80 chars. ### Breaking changes (if applicable) * Add `!` after type/scope: `feat!: ...` or `feat(tools)!: ...` * Add footer: * `BREAKING CHANGE: <what breaks and migration notes>` 5. **Commit** * One-liner (no body/footer needed): * `git commit -m "..."` * Otherwise: * `git commit` and write subject + body in editor. 6. **Post-commit sanity** * `git show --stat` * Ensure no accidental files were committed. 7. **Push** * `git push` 8. **Create Pull Request (if none exists)** * After pushing, check whether a PR already exists
Orchestrate the full PR creation workflow — commit, branch, push, create PR via gh CLI, and optionally poll for Qodo code review results. Use this skill whenever the user asks to "create a PR", "open a PR", "submit a PR", "commit and push and create a PR", or any variation of making a pull request. Also trigger when the user says "let's PR this" or "ship it" in a context where there are uncommitted or unpushed changes.
Create a git commit with staged changes
Stage and commit uncommitted changes with conventional commit messages. Use for committing changes or grouping commits by topic.
Generate conventional commit messages following project standards. Use when staging changes need a commit message or reviewing commit history.
Generates git commit messages following conventional commit standards with collaborative attribution. Use when user requests commit message creation, drafting, or help with formatting.
Stages all changes, guards against unignored junk files, and generates a conventional commit. Triggered when the user runs /commit or asks to commit.
Use when the user asks to commit, or says 'commit', '/commit', or '/tandem:commit'. Orchestrates structured commit authoring with the full memory pipeline.
skill-sample/ ├─ SKILL.md ⭐ Required: skill entry doc (purpose / usage / examples / deps) ├─ manifest.sample.json ⭐ Recommended: machine-readable metadata (index / validation / autofill) ├─ LICENSE.sample ⭐ Recommended: license & scope (open source / restriction / commercial) ├─ scripts/ │ └─ example-run.py ✅ Runnable example script for quick verification ├─ assets/ │ ├─ example-formatting-guide.md 🧩 Output conventions: layout / structure / style │ └─ example-template.tex 🧩 Templates: quickly generate standardized output └─ references/ 🧩 Knowledge base: methods / guides / best practices ├─ example-ref-structure.md 🧩 Structure reference ├─ example-ref-analysis.md 🧩 Analysis reference └─ example-ref-visuals.md 🧩 Visual reference
More Agent Skills specs Anthropic docs: https://agentskills.io/home
├─ ⭐ Required: YAML Frontmatter (must be at top) │ ├─ ⭐ name : unique skill name, follow naming convention │ └─ ⭐ description : include trigger keywords for matching │ ├─ ✅ Optional: Frontmatter extension fields │ ├─ ✅ license : license identifier │ ├─ ✅ compatibility : runtime constraints when needed │ ├─ ✅ metadata : key-value fields (author/version/source_url...) │ └─ 🧩 allowed-tools : tool whitelist (experimental) │ └─ ✅ Recommended: Markdown body (progressive disclosure) ├─ ✅ Overview / Purpose ├─ ✅ When to use ├─ ✅ Step-by-step ├─ ✅ Inputs / Outputs ├─ ✅ Examples ├─ 🧩 Files & References ├─ 🧩 Edge cases ├─ 🧩 Troubleshooting └─ 🧩 Safety notes
Skill files are scattered across GitHub and communities, difficult to search, and hard to evaluate. SkillWink organizes open-source skills into a searchable, filterable library you can directly download and use.
We provide keyword search, version updates, multi-metric ranking (downloads / likes / comments / updates), and open SKILL.md standards. You can also discuss usage and improvements on skill detail pages.
Quick Start:
Import/download skills (.zip/.skill), then place locally:
~/.claude/skills/ (Claude Code)
~/.codex/skills/ (Codex CLI)
One SKILL.md can be reused across tools.
Everything you need to know: what skills are, how they work, how to find/import them, and how to contribute.
A skill is a reusable capability package, usually including SKILL.md (purpose/IO/how-to) and optional scripts/templates/examples.
Think of it as a plugin playbook + resource bundle for AI assistants/toolchains.
Skills use progressive disclosure: load brief metadata first, load full docs only when needed, then execute by guidance.
This keeps agents lightweight while preserving enough context for complex tasks.
Use these three together:
Note: file size for all methods should be within 10MB.
Typical paths (may vary by local setup):
One SKILL.md can usually be reused across tools.
Yes. Most skills are standardized docs + assets, so they can be reused where format is supported.
Example: retrieval + writing + automation scripts as one workflow.
Some skills come from public GitHub repositories and some are uploaded by SkillWink creators. Always review code before installing and own your security decisions.
Most common reasons:
We try to avoid that. Use ranking + comments to surface better skills:
