Skip to content
Back to search

vibe-plugins

SkillGitHubIncomplete

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/ash1794--vibe-engineering/badge.svg)](/listings/ash1794--vibe-engineering)

HTML

<a href="/listings/ash1794--vibe-engineering"><img src="/api/listings/ash1794--vibe-engineering/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Claude Code

From inside a Claude Code session:

# 1. Add the marketplace (one-time)
/plugin marketplace add ash1794/vibe-engineering

# 2. Install the plugin
/plugin install vibe-engineering@vibe-plugins

Later, pull updates with `/plugin marketplace update vibe-plugins`.

Local development (unpackaged, for testing plugin changes):

git clone https://github.com/ash1794/vibe-engineering.git
claude --plugin-dir ./vibe-engineering/plugins/vibe-engineering

All 33 skills are now available in every Claude Code session.

OpenAI Codex & Gemini CLI

Both read skills from `.agents/skills/`, the cross-tool path in the Agent Skills standard, so one set of symlinks covers both:

# Clone once, symlink many times
git clone https://github.com/ash1794/vibe-engineering.git ~/src/vibe-engineering

# User-wide (available in all projects)
mkdir -p ~/.agents/skills
ln -s ~/src/vibe-engineering/plugins/vibe-engineering/skills/* ~/.agents/skills/

# Or per-project
mkdir -p .agents/skills
ln -s ~/src/vibe-engineering/plugins/vibe-engineering/skills/* .agents/skills/

Gemini CLI also accepts `~/.gemini/skills/` and `.gemini/skills/`. Run `/skills` in Gemini CLI to confirm the skills were discovered.

> **Upgrading from 1.x with symlinks?** Skill folders were renamed to match their `name` (e.g. `quality-loop/` → `vibe-quality-loop/`) and 9 skills were retired, so remove your old symlinks and re-run the `ln -s` command above.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 40 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "vibe-plugins",
  3. "metadata": {
  4. "description": "Marketplace for vibe-engineering plugins — engineering discipline skills for Claude Code, OpenAI Codex, and Gemini CLI"
  5. },
  6. "owner": {
  7. "name": "Ashwin K",
  8. "email": "ash1794@gmail.com"
  9. },
  10. "plugins": [
  11. {
  12. "name": "vibe-engineering",
  13. "source": "./plugins/vibe-engineering",
  14. "description": "33 engineering discipline skills — research, quality gates, reward-hacking checks, testing patterns, deployment, gap analysis, spec sync, and more. Extracted from real-world development.",
  15. "version": "2.3.0",
  16. "author": {
  17. "name": "Ashwin K",
  18. "email": "ash1794@gmail.com"
  19. },
  20. "homepage": "https://github.com/ash1794/vibe-engineering",
  21. "repository": "https://github.com/ash1794/vibe-engineering",
  22. "license": "MIT",
  23. "category": "development",
  24. "keywords": [
  25. "skills",
  26. "engineering",
  27. "quality",
  28. "testing",
  29. "debugging",
  30. "deployment",
  31. "tdd",
  32. "code-review",
  33. "best-practices",
  34. "workflows",
  35. "vibe-coding",
  36. "discipline"
  37. ]
  38. }
  39. ]
  40. }
README.md · README · 425 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # vibe-engineering
  2. [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  3. [![Claude Code Plugin](https://img.shields.io/badge/Claude%20Code-Plugin-blueviolet)](https://github.com/ash1794/vibe-engineering)
  4. [![OpenAI Codex Skills](https://img.shields.io/badge/OpenAI%20Codex-Skills-10a37f)](https://developers.openai.com/codex/skills/)
  5. [![Gemini CLI Skills](https://img.shields.io/badge/Gemini%20CLI-Skills-4285F4)](https://github.com/google-gemini/gemini-cli/blob/main/docs/cli/skills.md)
  6. [![Release](https://img.shields.io/github/v/release/ash1794/vibe-engineering)](https://github.com/ash1794/vibe-engineering/releases/latest)
  7. [![Skills](https://img.shields.io/badge/Skills-33-green)](https://github.com/ash1794/vibe-engineering)
  8. **33 engineering discipline skills for Claude Code, OpenAI Codex & Gemini CLI + a CLI for CI/CD enforcement.** Extracted from real-world multi-agent system development: not theoretical best practices, but patterns that survived 3 weeks of intensive production development with 205+ test files, 11 agents, and 50+ session observations.
  9. > "Vibe coding" meets engineering rigor. Every skill here exists because skipping it caused real pain, and every skill was re-checked in v2.0 against what current models and agent harnesses now handle on their own.
  10. ### Two commands. Instant engineering discipline.
  11. ```bash
  12. /plugin marketplace add ash1794/vibe-engineering
  13. /plugin install vibe-engineering@vibe-plugins
  14. ```
  15. Your agent picks the right skill from its description: research before design, quality gates before shipping, evidence before claiming "done."
  16. ## What's new in v2.3
  17. - **`vibe-cli` works on macOS.** It runs under the stock bash 3.2, and its scans no longer pass silently with BSD grep, which used to report CLEAN with a secret staged. `--json` output is now valid on every command. CI checks that a staged secret is blocked.
  18. - **Sharper skill triggers**: nine skills now say when to use them in their descriptions, so agents pick them more reliably.
  19. Earlier releases:
  20. - **v2.2** added `vibe-slop-filter` for prose that reads as machine-written, and `vibe-devil-advocate-review` now reviews any artifact from a named senior expert's standards, reporting only evidenced findings.
  21. - **v2.1** added `vibe-workstream-orchestration`, `vibe-publication-leak-guard`, and `vibe-flake-root-cause` from a multi-agent production build, plus panel mode, deploy provenance, wind-down handovers, and performance budgets in existing skills.
  22. - **v2.0** re-audited every skill against current Claude, GPT, and Gemini models and consolidated 38 skills into 29. If you're upgrading from v1.x, read the [migration notes](CHANGELOG.md#200---2026-09-25).
  23. Full history: [CHANGELOG](CHANGELOG.md) · [Releases](https://github.com/ash1794/vibe-engineering/releases)
  24. ## What is this?
  25. A skill collection in the open [Agent Skills](https://agentskills.io) format with 33 skills that enforce engineering discipline across any project, plus a lightweight CLI (`vibe-cli`) for CI/CD pipelines and automation:
  26. - **Research & Decision-Making** (3 skills): think before building
  27. - **Quality Gates & Validation** (8 skills): catch issues before they ship
  28. - **Knowledge & Continuity** (2 skills): never solve the same problem twice
  29. - **Parallel & Multi-Agent Development** (3 skills): scale your work safely
  30. - **Testing Patterns** (6 skills): test what matters, not just what's easy
  31. - **Deployment & Operations** (5 skills): ship with confidence
  32. - **Gap Analysis & Remediation** (2 skills): audit and systematically close gaps
  33. - **Process** (3 skills): stay focused, build to the right standard
  34. - **Meta** (1 skill): skill routing
  35. ### What the skills *don't* do
  36. Modern models and harnesses already handle some things well, and a skill that duplicates them only adds noise. v2.0 removed skills for context-window management (harnesses compact automatically), output formatting (models format well by default), always-on skill bootstrapping (skills trigger from their descriptions), and private task queues (use your issue tracker). See [CHANGELOG](CHANGELOG.md#200---2026-09-25) for the full list and migration.
  37. ## Installation
  38. ### Claude Code
  39. From inside a Claude Code session:
  40. ```bash
  41. # 1. Add the marketplace (one-time)
  42. /plugin marketplace add ash1794/vibe-engineering
  43. # 2. Install the plugin
  44. /plugin install vibe-engineering@vibe-plugins
  45. ```
  46. Later, pull updates with `/plugin marketplace update vibe-plugins`.
  47. Local development (unpackaged, for testing plugin changes):
  48. ```bash
  49. git clone https://github.com/ash1794/vibe-engineering.git
  50. claude --plugin-dir ./vibe-engineering/plugins/vibe-engineering
  51. ```
  52. All 33 skills are now available in every Claude Code session.
  53. ### OpenAI Codex & Gemini CLI
  54. Both read skills from `.agents/skills/`, the cross-tool path in the Agent Skills standard, so one set of symlinks covers both:
  55. ```bash
  56. # Clone once, symlink many times
  57. git clone https://github.com/ash1794/vibe-engineering.git ~/src/vibe-engineering
  58. # User-wide (available in all projects)
  59. mkdir -p ~/.agents/skills
  60. ln -s ~/src/vibe-engineering/plugins/vibe-engineering/skills/* ~/.agents/skills/
  61. # Or per-project
  62. mkdir -p .agents/skills
  63. ln -s ~/src/vibe-engineering/plugins/vibe-engineering/skills/* .agents/skills/
  64. ```
  65. Gemini CLI also accepts `~/.gemini/skills/` and `.gemini/skills/`. Run `/skills` in Gemini CLI to confirm the skills were discovered.
  66. > **Upgrading from 1.x with symlinks?** Skill folders were renamed to match their `name` (e.g. `quality-loop/` → `vibe-quality-loop/`) and 9 skills were retired, so remove your old symlinks and re-run the `ln -s` command above.
  67. ## Quick Start
  68. After installation, skills activate automatically when a task matches their description.
  69. Find the right skill:
  70. ```
  71. /vibe-engineering:vibe-help # Claude Code
  72. $vibe-help # Codex
  73. ```
  74. Invoke any skill directly:
  75. ```
  76. # Claude Code
  77. /vibe-engineering:vibe-quality-loop
  78. /vibe-engineering:vibe-research-before-design
  79. # Codex
  80. $vibe-quality-loop
  81. $vibe-research-before-design
  82. ```
  83. In Gemini CLI, skills are activated automatically from their descriptions, or you can ask for one by name.
  84. ## CLI: `vibe-cli`
  85. The `vibe-cli` CLI wraps critical skills into CI/CD-friendly commands with proper exit codes and JSON output. Pure bash (3.2+, so stock macOS works) plus GNU grep for its PCRE scans. Linux has it already; on macOS, `brew install grep`. Without it the CLI stops with an error instead of reporting a false CLEAN.
  86. ### Setup
  87. ```bash
  88. # Make it available system-wide (optional)
  89. ln -s $(pwd)/scripts/vibe-cli /usr/local/bin/vibe-cli
  90. # Or run directly from the repo
  91. ./scripts/vibe-cli help
  92. ```
  93. ### Commands
  94. ```bash
  95. vibe-cli pre-commit # Scan staged changes for secrets, debug code, disabled tests
  96. vibe-cli coverage # Run test coverage and report against tier targets
  97. vibe-cli spec-drift # Detect spec-code drift from staged changes
  98. vibe-cli decisions # Extract decisions from staged diff
  99. vibe-cli validate # Validate skill files and manifests
  100. vibe-cli hook install # Install as git pre-commit hook
  101. vibe-cli hook uninstall # Remove git pre-commit hook
  102. ```
  103. ### Exit Codes
  104. | Code | Meaning |
  105. |------|---------|
  106. | `0` | All checks passed |
  107. | `1` | Blocking issues (CI should fail) |
  108. | `2` | Warnings only (non-blocking) |
  109. ### JSON Output
  110. Every command supports `--json` for machine-readable output:
  111. ```bash
  112. vibe-cli pre-commit --json
  113. # {"status":"fail","blockers":1,"warnings":3,"findings":[...]}
  114. vibe-cli coverage --json --spec docs/spec.md
  115. # {"status":"pass","tool":"pytest","line_coverage":85,"spec_to_test":{"total":12,"covered":8}}
  116. vibe-cli spec-drift --json --spec docs/spec.md
  117. # {"status":"drift_detected","drift_items":3,"spec":"docs/spec.md","items":[...]}
  118. vibe-cli decisions --json
  119. # {"status":"decisions_found","count":4,"files_changed":7,"decisions":[...]}
  120. ```
  121. ### CI/CD Integration
  122. **GitHub Actions:**
  123. ```yaml
  124. - name: Vibe pre-commit check
  125. run: ./scripts/vibe-cli pre-commit --json
  126. - name: Coverage check
  127. run: ./scripts/vibe-cli coverage --spec docs/spec.md
  128. ```
  129. **GitLab CI:**
  130. ```yaml
  131. vibe-checks:
  132. script:
  133. - ./scripts/vibe-cli pre-commit
  134. - ./scripts/vibe-cli coverage --spec docs/spec.md
  135. ```
  136. **Pre-commit hook (automatic):**
  137. ```bash
  138. # Install once — blocks commits with secrets, debug code, etc.
  139. ./scripts/vibe-cli hook install
  140. ```
  141. ### Environment Variables
  142. | Variable | Purpose |
  143. |----------|---------|
  144. | `VIBE_OUTPUT=json` | Same as `--json` |
  145. | `VIBE_SPEC=<path>` | Default spec path for spec-drift/coverage |
  146. | `VIBE_TEST_DIR=<path>` | Default test directory |
  147. | `NO_COLOR=1` | Disable colored output |
  148. ## The Spec-Code-Test Loop
  149. Four skills form a connected workflow that keeps spec, tests, and code in sync:
  150. ```
  151. Code changes
  152. ↓
  153. vibe-decision-journal ──→ Extract decisions from diffs
  154. ↓
  155. vibe-spec-sync ──→ Update spec to reflect approved decisions
  156. ↓
  157. vibe-adversarial-test-generation ──→ Generate spec-driven tests with req:ID traceability
  158. ↓
  159. vibe-coverage-enforcer ──→ Verify 3 dimensions (line + spec-to-test + spec-to-code)
  160. ↓
  161. vibe-spec-sync --audit ──→ Final verification: no remaining gaps
  162. ```
  163. The CLI exposes the critical parts for automation:
  164. - `vibe-cli decisions` → extract decisions from staged changes
  165. - `vibe-cli spec-drift` → detect spec-code drift
  166. - `vibe-cli coverage` → verify all coverage dimensions
  167. - `vibe-cli pre-commit` → block commits with secrets/debug code
  168. ## Skill Catalog
  169. ### Meta
  170. | Skill | Trigger | Purpose |
  171. |-------|---------|---------|
  172. | `vibe-help` | "What skill should I use?" | Skill router and full catalog |
  173. ### Research & Decision-Making
  174. | Skill | Trigger | Purpose |
  175. |-------|---------|---------|
  176. | `vibe-research-before-design` | Before any new feature/architecture/tech choice | Research real projects, papers, and documented failures, with verified sources |
  177. | `vibe-decision-journal` | After any architectural choice or before committing | Automatic decision extraction from diffs + ADR recording |
  178. | `vibe-devil-advocate-review` | Before shipping recommendations, large changes, or multi-agent releases; any "tear this apart" request | 5-dimension challenge from a named senior expert's standards, by a fresh context or different model; only evidenced findings survive; panel mode runs parallel lenses with a verification stage |
  179. ### Quality Gates & Validation
  180. | Skill | Trigger | Purpose |
  181. |-------|---------|---------|
  182. | `vibe-acceptance-gate` | After completing a task with criteria | PASS/FAIL validation against criteria, with evidence |
  183. | `vibe-quality-loop` | After any non-trivial implementation | Review→Test→Fix loop until clean, using the repo's own checks |
  184. | `vibe-anti-rationalization-check` | Before claiming done; when a test is "in the way" | Catches reward hacking: test tampering, special-casing, unverified claims |
  185. | `vibe-spec-sync` | Before committing, or when implementation is claimed complete | Spec drift detection + approved write-back; `--audit` for full spec-vs-code check |
  186. | `vibe-doc-quality-gate` | After editing any technical doc | Fast 6-point document quality check |
  187. | `vibe-requirements-validator` | When reviewing PRD/user stories | SMART criteria validation |
  188. | `vibe-coverage-enforcer` | Before claiming code complete | 3-dimension coverage: line + spec-to-test + spec-to-code |
  189. | `vibe-slop-filter` | Before shipping prose a person will read (docs, release notes, PR descriptions, posts) | Counts AI-writing tells first, then keeps only the devices doing real work |
  190. ### Knowledge & Continuity
  191. | Skill | Trigger | Purpose |
  192. |-------|---------|---------|
  193. | `vibe-reflect-and-compound` | After feedback, a non-trivial bug, or a repeated pattern | Learnings, bug entries, and patterns written to the memory file your agent loads (CLAUDE.md / AGENTS.md / GEMINI.md) |
  194. | `vibe-handover-doc` | Handing off, switching tools, or hitting a usage limit | Current-state-first handover with resume prompt; wind-down mode for interrupted multi-agent work |
  195. ### Parallel & Multi-Agent Development
  196. | Skill | Trigger | Purpose |
  197. |-------|---------|---------|
  198. | `vibe-parallel-task-decomposition` | Large task with independent subtasks | DAG analysis and dispatch plan for the harness's native subagents |
  199. | `vibe-workstream-orchestration` | Multi-phase project with 3+ agents at once | Orchestrator-only main thread, long-lived file-owning workstreams, route-don't-spawn, stale-checkout and shared-machine hygiene |
  200. | `vibe-cherry-pick-integration` | After parallel agents complete | Safe sequential integration of branches/worktrees |
  201. ### Testing Patterns
  202. | Skill | Trigger | Purpose |
  203. |-------|---------|---------|
  204. | `vibe-golden-file-testing` | Snapshot/golden test implementation | Temporal normalization, update commands |
  205. | `vibe-scenario-matrix` | Planning test coverage | Behavioral scenario acceptance matrix |
  206. | `vibe-concurrent-test-safety` | Tests with shared mutable state | Race condition and cleanup auditing |
  207. | `vibe-adversarial-test-generation` | After happy-path tests written | Edge case + spec-driven test generation with req:ID traceability |
  208. | `vibe-fuzz-parser-inputs` | Implementing any parser | Fuzz test scaffolding and corpus |
  209. | `vibe-flake-root-cause` | "Passed on rerun", CI-only or intermittent failures | Force the controlling variable, reproduce at a stated rate, fix the cause, prove it with counts |
  210. ### Deployment & Operations
  211. | Skill | Trigger | Purpose |
  212. |-------|---------|---------|
  213. | `vibe-pre-commit-audit` | Before creating a commit | Runs hooks/secret scanners first, then checks for secrets, debug code, TODOs |
  214. | `vibe-publication-leak-guard` | Publishing agent-drafted or privately sourced content | Two-tier scan of built output, WIP visible in preview and absent in production, human-owned approval ledger |
  215. | `vibe-safe-deploy` | Before any deployment | Pre-flight checks, atomic deploy, SHA provenance check, rollback |
  216. | `vibe-rollback-plan` | Before risky changes | Documented rollback runbook |
  217. | `vibe-service-health-dashboard` | Checking running services | Multi-service health monitoring |
  218. ### Gap Analysis & Remediation
  219. | Skill | Trigger | Purpose |
  220. |-------|---------|---------|
  221. | `vibe-gap-analysis` | Before production launch or after major refactor | 17-dimension production readiness audit with parallel agents |
  222. | `vibe-gap-closure-loop` | 10+ findings, bugs, or audit items | Prioritized waves → parallel fix streams → test gate → re-audit |
  223. ### Process
  224. | Skill | Trigger | Purpose |
  225. |-------|---------|---------|
  226. | `vibe-scope-guard` | During implementation | Scope creep and over-engineering detection |
  227. | `vibe-production-mindset` | Before declaring a production feature done | Production hardening checklist scaled to real stakes, incl. performance budgets that are never loosened to pass |
  228. | `vibe-iteration-review` | End of development iteration | Quality grading and trend analysis |
  229. ## Why vibe-engineering?
  230. AI coding agents are far more capable than they were a year ago, but some failure modes persist: satisfying the test instead of the goal, over-building, claiming "done" without evidence, and agreeing with their own first idea. **vibe-engineering targets exactly those.**
  231. | Without | With vibe-engineering |
  232. |---------|----------------------|
  233. | "Let me just build it" | Research existing solutions and their failures first (`vibe-research-before-design`) |
  234. | "Tests pass, ship it" | Check coverage standards are met (`vibe-coverage-enforcer`) |
  235. | "I'll remember the decision" | Extract it automatically from diffs (`vibe-decision-journal`) |
  236. | "Good enough" | Loop until clean, with evidence (`vibe-quality-loop`) |
  237. | "Spec is probably still accurate" | Detect drift and sync back (`vibe-spec-sync`) |
  238. | Test loosened until it passed | Caught and disclosed (`vibe-anti-rationalization-check`) |
  239. | Same bug investigated twice | Root cause saved to the agent's memory file (`vibe-reflect-and-compound`) |
  240. | Self-review that agrees with itself | Review by a fresh context or another model (`vibe-devil-advocate-review`) |
  241. | Release notes that read like a chatbot wrote them | Tells counted and cut (`vibe-slop-filter`) |
  242. ## Design Principles
  243. 1. **Born from pain, not theory**: every skill exists because skipping it caused real problems
  244. 2. **Don't duplicate the model**: if current models or harnesses already do it well, it's not a skill
  245. 3. **When to use AND when NOT to use**: every skill has explicit triggers and anti-triggers
  246. 4. **Harness-neutral**: skills describe capabilities, not one tool's API, and never hard-code a model (see [`references/platform-tools.md`](references/platform-tools.md))
  247. 5. **Composable**: skills work independently or together
  248. 6. **Advisory first, enforcement when it matters**: skills guide; the CLI enforces in CI/CD
  249. ## How It Works
  250. The repo is a Claude Code **marketplace** (`vibe-plugins`) that ships one plugin (`vibe-engineering`), whose `skills/` directory is also a standard Agent Skills collection for Codex and Gemini CLI:
  251. - **Claude Code**: `.claude-plugin/marketplace.json` at the repo root catalogs the plugin; the plugin itself lives in `plugins/vibe-engineering/` with its own `.claude-plugin/plugin.json`
  252. - **Codex & Gemini CLI**: `.agents/skills/` symlinks into the plugin's `skills/` directory; both discover skills from this standard path
  253. ```
  254. vibe-engineering/ # repo root = marketplace root
  255. ├── .claude-plugin/
  256. │ └── marketplace.json # marketplace: "vibe-plugins"
  257. ├── plugins/
  258. │ └── vibe-engineering/ # plugin root
  259. │ ├── .claude-plugin/plugin.json # plugin: "vibe-engineering"
  260. │ └── skills/ # 33 skill definitions
  261. │ ├── vibe-help/SKILL.md
  262. │ ├── vibe-quality-loop/SKILL.md
  263. │ ├── vibe-spec-sync/SKILL.md
  264. │ └── ... (folder name == skill name)
  265. ├── .agents/
  266. │ └── skills → ../plugins/vibe-engineering/skills # Codex + Gemini CLI discovery
  267. ├── AGENTS.md # Codex / cross-tool project instructions
  268. ├── CLAUDE.md # Claude Code project instructions (repo invariants)
  269. ├── GEMINI.md # Gemini CLI project instructions (imports AGENTS.md)
  270. ├── references/
  271. │ └── platform-tools.md # Capability mapping across Claude Code, Codex, Gemini CLI
  272. ├── scripts/
  273. │ ├── vibe-cli # CLI for CI/CD enforcement
  274. │ └── validate-skills.sh # Skill file validator
  275. ├── CHANGELOG.md
  276. └── README.md
  277. ```
  278. Each skill has:
  279. - **YAML frontmatter** with `name` (matching its folder) and `description`
  280. - **When to Use**: explicit triggers
  281. - **When NOT to Use**: anti-triggers to prevent misapplication
  282. - **Steps**: the actual workflow
  283. - **Output Format**: structured output template
  284. ## Contributing
  285. Found a pattern that keeps saving you? Turn it into a skill:
  286. 1. Fork this repo
  287. 2. Create `plugins/vibe-engineering/skills/vibe-your-skill-name/SKILL.md` (the folder name must equal `name`)
  288. 3. Follow the template below and the portability rules in [`references/platform-tools.md`](references/platform-tools.md)
  289. 4. Add it to the catalog in this README and in `vibe-help`
  290. 5. Run `bash scripts/validate-skills.sh`, then submit a PR
  291. Before adding a skill, ask: *would a current frontier model do this well without being told?* If yes, it isn't a skill.
  292. ### Skill Template
  293. ```markdown
  294. ---
  295. name: vibe-your-skill-name
  296. description: Performs [action] for [context]. Use when [trigger condition].
  297. user-invocable: true
  298. ---
  299. # vibe-your-skill-name
  300. [One paragraph explaining the problem this skill solves]
  301. ## When to Use This Skill
  302. - [Trigger 1]
  303. - [Trigger 2]
  304. ## When NOT to Use This Skill
  305. - [Anti-trigger 1]
  306. - [Anti-trigger 2]
  307. ## Steps
  308. 1. [Step 1]
  309. 2. [Step 2]
  310. ## Output Format
  311. [Template for structured output]
  312. ```
  313. ## Origin Story
  314. These skills were extracted from building an 11-agent personal assistant system with Go backend, React Native frontend, and 205+ test files.
  315. **The numbers:**
  316. - 50+ session observations analyzed (310k+ tokens of development history)
  317. - 15 project-specific skills generalized into 38 universal patterns (v1.x)
  318. - Consolidated to 29 in v2.0 after re-auditing each one against current Claude, GPT, and Gemini models; v2.1 added 3 from a multi-agent production build; v2.2 added 1 for prose quality
  319. - Every skill represents a pattern that emerged from real pain — not a theoretical best practice document
  320. ## Also Check Out
  321. - **[bart-coaching](https://github.com/ash1794/bart-coaching)** — Growth-oriented coaching hooks for Claude Code. Provides real-time technical depth insights, operational maturity nudges, and behavioral self-awareness mirrors with compound reflections across sessions. Pairs well with vibe-engineering for engineers who want both discipline tools and growth feedback.
  322. ## License
  323. MIT — Use it, fork it, make it yours.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.