VS Code Copilot Skills

Portable personal skills for coding agents.

Layout

• skills//SKILL.md
• Optional per skill:
  • scripts/
  • references/
  • assets/

Install on a machine

1. Clone this repo to your home directory.
2. Sync to local Copilot skill path: cp -a skills/. ~/.copilot/skills/

Or use symlink mode: ln -sfn "$PWD/skills" ~/.copilot/skills

Notes

• Folder name must match the name field in SKILL.md.
• Use lowercase letters, numbers, and hyphens for skill names.

Third-Party Skills

Some skills in this repo are adapted from third-party sources (e.g., Anthropic/Claude skills). Each skill folder includes its own LICENSE file. When adding third-party skills:

• Keep the original LICENSE file intact.
• If you modify the skill, add a short note at the top of SKILL.md:
  • "Modified from original [Source] skill to be model-agnostic."
  • Include original license and copyright line.
• Generalize any vendor-specific references (e.g., "Claude", "Anthropic") so the skill works with any model.

Skill Expansion Plan (Qwen Coding Reliability)

Goal: improve local-model coding reliability by turning common engineering work into reusable, testable skills with deterministic workflows.

Why this plan

• Local models improve most when prompts become structured workflows.
• Skills reduce variance by enforcing: scope, sequence, validation, and completion checks.
• Scripted helpers are useful only for repetitive/deterministic tasks (scaffold, validate, bundle, bootstrap).

Current strengths in this repo

• Frontend artifacting and UX: strong (web-artifacts-builder, HTML Sandbox Artifact Builder, frontend-design, brand-guidelines).
• Debugging and iteration: strong (root-cause-debug-workflow, skill-creator).
• Containerization baseline: present (docker-forgejo).

Main gaps to fill

• Backend architecture workflows (Go/API).
• DevOps workflows (runtime operations, deeper deployment policy patterns).
• Delivery workflows (Git branching, PR standards, release tagging).

Progress update (implemented)

Implemented skill frameworks (SKILL.md + references + scripts + evals):

1. backend-python-api-builder
2. sql-data-layer-workflow
3. fullstack-app-bootstrap
4. ci-cd-pipeline-builder
5. kubernetes-deployment-workflow

These skills include starter evals/evals.json prompts for side-by-side testing over the next iteration cycle.

Build roadmap

Phase 1 (Foundation)

1. backend-python-api-builder
2. sql-data-layer-workflow
3. git-delivery-workflow

Phase 2 (App assembly)

1. fullstack-app-bootstrap
2. docker-compose-runtime-workflow
3. http-contract-testing-workflow

Phase 3 (Deployment and scale)

1. ci-cd-pipeline-builder
2. kubernetes-deployment-workflow
3. go-service-builder

Recommended first skill set (priority order)

1. backend-python-api-builder

• Outcome: production-ready FastAPI/Flask skeleton with config, logging, health, tests.

2. sql-data-layer-workflow

• Outcome: schema + migrations + query validation checklist for SQLite/PostgreSQL.

3. fullstack-app-bootstrap

• Outcome: repeatable frontend+backend+db project layout and run flow.

4. ci-cd-pipeline-builder

• Outcome: baseline pipeline templates for lint/test/build/publish/deploy.

5. kubernetes-deployment-workflow

• Outcome: Deployment/Service/Ingress/HPA + rollout/debug runbook.

Skill framework standard

Use this structure for all new skills:

skills/<skill-name>/
  SKILL.md
  references/
   checklist.md
   patterns.md
  scripts/                 # only when deterministic helpers are needed
   bootstrap.sh
   validate.sh
  evals/
   evals.json

Required SKILL.md sections:

1. Outcome
2. When to Use
3. When Not to Use
4. Inputs Required
5. Procedure (step-by-step)
6. Decision Points
7. Validation
8. Completion Checklist
9. Resources

Script policy (important)

Add scripts only when they prevent repeated model mistakes or repetitive setup.

Good script candidates:

• project bootstrap/scaffolding
• deterministic validation checks
• bundle/export/packaging steps

Avoid scripts for:

• one-off reasoning
• simple instructions that are stable in SKILL.md only

Evaluation loop for every new skill

1. Draft skill using skill-template.
2. Create 3-5 realistic prompts in evals/evals.json.
3. Run with-skill vs without-skill baselines.
4. Score output quality, time, and token usage.
5. Tighten triggering description and procedure.
6. Keep only instructions that improve measurable outcomes.

Git workflow for this repo

Branch naming:

• feat/skill-<name> for new skills
• improve/skill-<name> for revisions
• chore/skills-docs for repo-wide docs/process updates

Commit style:

• feat(skill): add backend-python-api-builder skeleton
• docs(plan): add skill expansion roadmap
• refactor(skill): simplify trigger conditions

PR checklist:

1. Folder name matches name in SKILL.md
2. Trigger description is specific and keyword-rich
3. Includes When Not to Use to prevent over-triggering
4. Validation and completion checklist are explicit
5. If scripts exist, they have usage notes and are deterministic
6. If third-party derived, license and attribution are preserved

Immediate next execution steps

1. Run first test loop for:

• backend-python-api-builder
• sql-data-layer-workflow
• fullstack-app-bootstrap
• ci-cd-pipeline-builder
• kubernetes-deployment-workflow

2. Capture with-skill vs baseline outputs per eval prompt.
3. Add assertion-based grading for each eval case.
4. Generate benchmark summary and identify weak instructions.
5. Refine SKILL.md descriptions/procedures based on measured results.