convez.ai
MCP Server
v1-io

v1tamins

v1-io/v1tamins

Ver no GitHub
BomPluginScore · de 0 a 100

Daily supplements for healthy code - Shared Claude skills, Cursor commands, and MCP configs for the Version1 team

Instalação

$npx convez-ai v1-io/v1tamins

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
6
Forks
1
Acompanhando
0
Saúde
50%
Último commit
há 2 dias
Versão
v0.16.0
Issues abertas
2
Contribuidores
2

README

A tradução para o português deste README ainda está na fila.

v1tamins

██╗   ██╗  ██╗ ████████╗ █████╗ ███╗   ███╗██╗███╗   ██╗███████╗
██║   ██║ ███║ ╚══██╔══╝██╔══██╗████╗ ████║██║████╗  ██║██╔════╝
██║   ██║ ╚██║    ██║   ███████║██╔████╔██║██║██╔██╗ ██║███████╗
╚██╗ ██╔╝  ██║    ██║   ██╔══██║██║╚██╔╝██║██║██║╚██╗██║╚════██║
 ╚████╔╝   ██║    ██║   ██║  ██║██║ ╚═╝ ██║██║██║ ╚████║███████║
  ╚═══╝    ╚═╝    ╚═╝   ╚═╝  ╚═╝╚═╝     ╚═╝╚═╝╚═╝  ╚═══╝╚══════╝

AI coding agents fail in five predictable ways. v1tamins is one sharp skill for each.

Daily supplements for healthy code, from the Version1 team. Plugin install for Claude Code and Codex. Skills compose into the workflows you actually use — idea → ship, bug → fix, weekly compounding. Mix and match.

Install

v1tamins ships as a plugin for Claude Code and Codex. One shared skills/ directory under plugins/v1tamins/ serves both runtimes through sibling per-runtime manifests. Plugin-distributed skills carry a v1- prefix (v1-pr, v1-debug, v1-goldpan) to avoid colliding with other public or personal skills.

Claude Code

/plugin marketplace add v1-io/v1tamins
/plugin install v1tamins@v1tamins

For local development against a checkout, point the marketplace at the path:

/plugin marketplace add ~/v1tamins

Codex

codex plugin marketplace add v1-io/v1tamins

Then install or enable the v1tamins plugin from Codex's plugin UI. For local development use ~/v1tamins in place of v1-io/v1tamins.

Updates flow through the runtime's marketplace refresh — there's nothing to rerun.

Recommended companion: compound-engineering

A few v1tamins skills compose directly with Every's compound-engineering plugin:

  • /v1-goldpan queues approved candidates through /ce-compound to write durable solution docs
  • /v1-pr chains into /ce-code-review for multi-agent review before merge

Install it alongside v1tamins:

# Claude Code
/plugin marketplace add EveryInc/compound-engineering-plugin
/plugin install compound-engineering@compound-engineering-plugin

# Codex
codex plugin marketplace add EveryInc/compound-engineering-plugin
# then install compound-engineering from Codex's plugin UI

[!NOTE] v1tamins works without it — only /v1-goldpan will fail noisily if compound-engineering isn't installed. Everything else degrades gracefully.

The skill universe

mindmap
  root((v1tamins))
    Plan
      ("v1-interview-me")
      ("v1-strategy-review")
      ("v1-bare-bones")
      ("v1-shared-language")
      ("v1-prd")
      ("v1-learning-from-customers")
      ("v1-testing-prototypes")
      ("v1-reviewing-usability")
    Build
      ("v1-debug")
      ("v1-fix-tests")
      ("v1-write-tests")
      ("v1-e2e-testing")
    Quality
      ("v1-simplify")
      ("v1-deslop")
      ("v1-refactor")
      ("v1-complexity")
      ("v1-hindsight-refactor")
      ("v1-deep-review")
      ("v1-diagnosing-constraints")
    Ship
      ("v1-pr")
      ("v1-pr-description")
      ("v1-land-pr")
      ("v1-code-review")
      ("v1-address-review")
      ("v1-prove-work")
    Compound
      ("v1-goldpan")
      ("v1-docs-freshness")
      ("v1-changelog")
    Communicate
      ("v1-stickify")
      ("v1-md2docs")
      ("v1-html-it")
      ("v1-reviewing-data-graphics")
    Research
      ("v1-deep-research")
      ("v1-autoresearch-skill")
      ("v1-canon2skill")
    Meta
      ("v1-skilling-it")
      ("v1-prompt-engineering")

Why these skills exist

You've felt all five of these:

  • The 800 lines that solved a different problem.
  • The bug fix that took three tries to actually fix.
  • The diff full of belt-and-braces error handling for cases that can't happen.
  • The PR that sat in draft for two days because writing the description felt like work.
  • The teammate who rediscovers your fix six months later because nobody wrote it down.

Each v1tamin is the smallest sharp tool we could build for one of those failures. None of them try to be the whole process.

Choose the right planning or review skill

NeedUseNot
Flesh out an idea through questionsv1-interview-meCustomer discovery plan, prototype test, or PRD
Plan/audit/synthesize customer conversationsv1-learning-from-customersGeneral feature spec or prototype usability test
Plan or synthesize observed prototype sessionsv1-testing-prototypesCustomer interviews before a prototype exists
Review UI task completion and error riskv1-reviewing-usabilityChart truthfulness or metric-dashboard integrity
Review charts, dashboards, or quantitative displaysv1-reviewing-data-graphicsGeneral app usability review
Diagnose a stuck process, queue, funnel, or roadmapv1-diagnosing-constraintsSpecific software bug reproduction
Debug a reproducible failure or flaky behaviorv1-debugBroad operational constraint diagnosis

You describe a feature. The agent writes 800 lines. About 60% solves a different problem. The rest is now your debugging tax.

[!TIP] The fix isn't better prompts. It's grilling the idea, building a shared vocabulary, and writing the requirements down — before any code gets written.

  • /v1-interview-me — office-hours-style questioning that takes a fuzzy idea ("what if we did X") and walks every branch of the decision tree until you can describe what you actually want
  • /v1-strategy-review — a CEO-style read of a plan, PRD, or proposal that pushes back on scope, ambition, and hidden assumptions ("is this big enough?")
  • /v1-bare-bones — strip an overscoped plan down to the smallest useful version before it turns into implementation sprawl
  • /v1-shared-language — extract a DDD-style glossary from the current conversation, flag ambiguous terms, and write LANGUAGE.md. Pays off session after session: variables, files, and prompts all start using one vocabulary
  • /v1-prd — turn a Linear ticket or feature request into a real PRD
  • /v1-learning-from-customers — plan, audit, and synthesize customer discovery so demand evidence comes from behavior, context, and commitments rather than compliments or hypotheticals
  • /v1-testing-prototypes — plan or synthesize prototype tests that separate value, usability, and feasibility evidence before engineering commits
  • /v1-reviewing-usability — review a UI, prototype, flow, form, or admin surface for discoverability, feedback, mapping, conceptual-model clarity, and user-error risk

Aligned and confident. You hit run. It crashes. The agent's first instinct is to wrap it in a try/except and declare victory.

[!TIP] Yours should be a failing test that pins the symptom. Short feedback loops beat long debugging sessions — failing tests, real reproductions, instrumentation before guesses.

  • /v1-debug — disciplined diagnosis loop: reproduce → minimise → hypothesise → instrument → fix → regression-test. The skill to reach for first when something is broken or flaky
  • /v1-fix-tests — systematic loop that fixes failing tests until the suite is green, with feedback at every step
  • /v1-write-tests — generate unit tests for new functionality with sensible coverage and meaningful assertions
  • /v1-e2e-testing — Playwright-based browser tests, including a playbook for de-flaking

Agents over-build. Extra try/except. Unused helpers. Premature abstractions. Defensive fallbacks for cases that can't happen. The code works — and the codebase gets a little harder to change.

[!IMPORTANT] Ship that diff once and the next change inherits its shape. Run a quality pass before marking work as done.

  • /v1-simplify — review recent changes for reuse, unnecessary complexity, and efficiency before considering the work shippable
  • /v1-deslop — strip AI-generated boilerplate, defensive checks, and verbose comments that add nothing
  • /v1-refactor — apply KISS / DRY / SOLID / YAGNI to a working diff
  • /v1-complexity — flatten nested code and reduce cognitive complexity in specific functions
  • /v1-hindsight-refactor — when the first-pass fix is exploratory or overbuilt, delete it and reimplement a clean version using what the first pass taught you
  • /v1-deep-review — unusually strict maintainability audit: abstraction quality, file-size boundaries, spaghetti branching, and ambitious structural simplification before merge

Code's done. Now: title, body, screenshots, push, watch CI, fix the lint failure, address the bot's three comments, fix the lint again, mark ready. Each step is a context switch — and the longer the diff sits, the colder it gets.

These skills compress the ship phase into one chained workflow.

  • /v1-pr — turn local work into a draft PR with a sensible title and body
  • /v1-pr-description — generate or refresh a PR title/body from metadata, diff, and validation evidence (use standalone or chained inside /v1-pr)
  • /v1-land-pr — the full hand-off: commit → push → open as draft → monitor gh pr checks → fix failed checks (up to 3 retries) → mark ready → move linked Linear ticket to Human Review
  • /v1-code-review — review the current branch or a specific PR with actionable, file-anchored feedback; posts to GitHub only when requested
  • /v1-address-review — work through unresolved review threads from Copilot, Code Factory, bots, or humans and reply with the right diff or context
  • /v1-prove-work — record a browser GIF of the new behaviour to drop into the PR description

[!WARNING] /v1-land-pr will mark a PR ready for review and move a linked Linear ticket to Human Review. Don't run it on work that isn't actually done.

The pain you can't feel in the moment: solving the same problem twice. Six months from now, a teammate hits the bug you fixed last sprint and rediscovers your solution in three days, because nobody wrote down what worked.

[!NOTE] Compounding requires fresh material. /v1-goldpan pans for it across PRs and session logs. /ce-compound writes it up. Run weekly — your future self is on the team too.

  • /v1-goldpan — pan recent merged PRs and agent session logs (Claude Code + Codex + Cursor) for compound-worthy moments, present the candidates, then queue them through /ce-compound for documentation
  • /v1-docs-freshness — sync READMEs and docs with what actually shipped (post-merge, post-release, or after a new skill lands)
  • /v1-changelog — generate release notes from recent merged PRs
  • /v1-canon2skill — turn books, PDFs, articles, courses, and notes into evidence-backed recommendations for new or improved reusable skills

Workflows that compose

Each skill does one thing. The leverage is the chain. These cycles are how Version1 actually ships — not idealised, just the paths we keep walking.

Idea → shipped feature

flowchart LR
  A([/v1-interview-me]) --> B([/v1-strategy-review])
  B --> C([/v1-bare-bones])
  C --> D([/v1-learning-from-customers])
  D --> E([/v1-prd])
  E --> F{{... build ...}}
  F --> G([/v1-simplify])
  G --> H([/v1-code-review])
  H --> I([/v1-pr])
  I --> J([/v1-prove-work])
  J --> K([/v1-land-pr])
  K -.weekly.-> L([/v1-goldpan])
  L -.feeds back.-> A
  click A href "./plugins/v1tamins/skills/v1-interview-me/SKILL.md"
  click B href "./plugins/v1tamins/skills/v1-strategy-review/SKILL.md"
  click C href "./plugins/v1tamins/skills/v1-bare-bones/SKILL.md"
  click D href "./plugins/v1tamins/skills/v1-learning-from-customers/SKILL.md"
  click E href "./plugins/v1tamins/skills/v1-prd/SKILL.md"
  click G href "./plugins/v1tamins/skills/v1-simplify/SKILL.md"
  click H href "./plugins/v1tamins/skills/v1-code-review/SKILL.md"
  click I href "./plugins/v1tamins/skills/v1-pr/SKILL.md"
  click J href "./plugins/v1tamins/skills/v1-prove-work/SKILL.md"
  click K href "./plugins/v1tamins/skills/v1-land-pr/SKILL.md"
  click L href "./plugins/v1tamins/skills/v1-goldpan/SKILL.md"

Bug investigation

flowchart LR
  A([/v1-debug]) --> B([/v1-write-tests])
  B --> C([/v1-simplify])
  C --> D([/v1-land-pr])
  click A href "./plugins/v1tamins/skills/v1-debug/SKILL.md"
  click B href "./plugins/v1tamins/skills/v1-write-tests/SKILL.md"
  click C href "./plugins/v1tamins/skills/v1-simplify/SKILL.md"
  click D href "./plugins/v1tamins/skills/v1-land-pr/SKILL.md"

PR review hand-off

flowchart LR
  A([/v1-code-review]) --> B([/v1-address-review])
  B --> C([/v1-land-pr])
  click A href "./plugins/v1tamins/skills/v1-code-review/SKILL.md"
  click B href "./plugins/v1tamins/skills/v1-address-review/SKILL.md"
  click C href "./plugins/v1tamins/skills/v1-land-pr/SKILL.md"

Weekly compounding

flowchart LR
  A([/v1-goldpan 7d]) --> B([/ce-compound])
  B --> C([/v1-docs-freshness])
  C --> D([/v1-changelog])
  click A href "./plugins/v1tamins/skills/v1-goldpan/SKILL.md"
  click C href "./plugins/v1tamins/skills/v1-docs-freshness/SKILL.md"
  click D href "./plugins/v1tamins/skills/v1-changelog/SKILL.md"

Communication

flowchart LR
  A([/v1-stickify]) -.-> B([/v1-md2docs])
  A -.-> C([/v1-prove-work])
  click A href "./plugins/v1tamins/skills/v1-stickify/SKILL.md"
  click B href "./plugins/v1tamins/skills/v1-md2docs/SKILL.md"
  click C href "./plugins/v1tamins/skills/v1-prove-work/SKILL.md"

Skill reference

Plan & align

SkillWhen to use
/v1-interview-meFuzzy idea, ticket, or feature request needs to be fleshed out before any code is written
/v1-strategy-reviewStress-test a plan, PRD, or product direction for scope, ambition, and hidden assumptions
/v1-bare-bonesStrip an overscoped plan down to the smallest useful version
/v1-shared-languageBuild a DDD glossary so devs and agents stop talking past each other
/v1-prdGenerate a PRD from a Linear ticket or feature request
/v1-learning-from-customersPlan, audit, and synthesize customer discovery without false-positive demand evidence
/v1-testing-prototypesPlan and synthesize prototype tests before build decisions
/v1-reviewing-usabilityReview product interactions for discoverability, feedback, conceptual-model clarity, and user-error risk

Build & debug

SkillWhen to use
/v1-debugDisciplined diagnosis loop for hard bugs, flakes, and perf regressions
/v1-fix-testsSystematic loop until the test suite is green
/v1-write-testsGenerate meaningful unit tests for new code
/v1-e2e-testingPlaywright tests, including a de-flaking playbook

Quality pass before merge

SkillWhen to use
/v1-simplifyReview recent changes for reuse, unnecessary complexity, and efficiency before declaring done
/v1-deslopStrip AI-generated boilerplate, defensive checks, and dead comments
/v1-refactorApply KISS / DRY / SOLID / YAGNI to a working diff
/v1-complexityReduce cognitive complexity in specific functions
/v1-hindsight-refactorThrow away the messy first-pass fix and reimplement cleanly using what it taught you
/v1-deep-reviewHarsh maintainability and structure audit on a large PR, new feature, or architecture change
/v1-diagnosing-constraintsFind the bottleneck or constraint governing throughput in a stuck process, team, queue, or roadmap

Ship

SkillWhen to use
/v1-prTurn local work into a draft PR
/v1-pr-descriptionGenerate or refresh a PR title and body from metadata, diff, and validation
/v1-land-prFull hand-off: commit → push → CI → fix → mark ready → update Linear
/v1-code-reviewMulti-angle review on the current branch or a specific PR; use --post or ask explicitly to post to GitHub
/v1-address-reviewResolve unresolved threads from Copilot, Code Factory, bots, or humans
/v1-prove-workRecord a browser GIF for the PR description or Slack

Compound the learning

SkillWhen to use
/v1-goldpanPan recent merged PRs + agent session logs for compound-worthy moments and queue them through /ce-compound
/v1-docs-freshnessSync READMEs and docs with what actually shipped
/v1-changelogGenerate release notes from recent merged PRs

Communication

SkillWhen to use
/v1-stickifyMake pitches, announcements, PR descriptions, or marketing copy memorable (Made-to-Stick framework)
/v1-md2docsPublish a Markdown doc as a fully-formatted Google Doc
/v1-html-itCreate polished self-contained HTML artifacts for reviews, explainers, reports, prototypes, or custom editors
/v1-reviewing-data-graphicsReview charts, dashboards, metric tables, and quantitative visual reports for integrity and clarity

Research

SkillWhen to use
/v1-deep-researchMulti-source research with iterative refinement and structured synthesis. Not for simple lookups
/v1-autoresearch-skillAutonomous optimization loop — point it at any measurable target and it iterates
/v1-canon2skillExtract reusable skill ideas from source material, including PDFs that need OCR

Meta — write the tools

SkillWhen to use
/v1-skilling-itCreate or improve a shared agent skill (this repo's own toolchain)
/v1-prompt-engineeringWrite or improve prompts, system prompts, hooks, or sub-agent briefs
/v1-prompt-engineering-v1taminsSame, specialised for GPT-5.5 / OpenAI Responses API / OpenRouter migrations

Repo layout

v1tamins/
├── .agents/plugins/         # Codex marketplace manifest
├── .claude-plugin/          # Claude Code marketplace manifest
├── plugins/v1tamins/        # Plugin package and canonical skill source
│   ├── .claude-plugin/      #   Claude Code plugin manifest
│   ├── .codex-plugin/       #   Codex plugin manifest
│   └── skills/              #   Canonical v1-* skills consumed by both runtimes
└── scripts/                 # Validation scripts

Migration Note

This package uses a plugin-native source layout. The committed skill source is plugins/v1tamins/skills/v1-<skill-name>/; the old .agents/skills/<skill-name>/ mirror is no longer tracked. Direct checkout consumers should update symlinks, scripts, and docs to point at the plugins/v1tamins/skills/v1-* paths and use the installed v1-* skill names.

Marketplace/plugin consumers already invoking /v1-* skills should not need to change anything.

Contributing

  1. Fork and clone, add upstream:
    git remote add upstream git@github.com:v1-io/v1tamins.git
    
  2. Create a branch.
  3. Edit the canonical skill at plugins/v1tamins/skills/v1-<skill-name>/SKILL.md. Each SKILL.md needs YAML frontmatter with a v1-* name matching the directory and a description. allowed-tools is recommended for skills that need tool restrictions; see v1-skilling-it for the full schema. Add an agents/openai.yaml when the skill should appear cleanly in Codex's skill list.
  4. Bump both runtime plugin manifest versions when runtime plugin content changes: plugins/v1tamins/.claude-plugin/plugin.json and plugins/v1tamins/.codex-plugin/plugin.json.
  5. Validate plugin manifests and skill frontmatter:
    scripts/validate-plugin.sh
    
  6. Test the skill in a real project before committing.
  7. Run a privacy and portability scan over your changes — no secrets, internal URLs, customer names, or absolute local paths.
  8. Open a PR.

Validation

scripts/validate-plugin.sh           # check
scripts/validate-plugin.sh --verbose # per-file trace

The check validates SKILL.md frontmatter, optional agents/openai.yaml metadata, the canonical plugins/v1tamins/skills/v1-* skills, local skill asset links, references to known v1tamins skills, portable helper paths, both runtime plugin manifests (plugins/v1tamins/.claude-plugin/plugin.json and plugins/v1tamins/.codex-plugin/plugin.json), both marketplace manifests (.claude-plugin/marketplace.json and .agents/plugins/marketplace.json), plugin version bumps when runtime content changes, and the absence of a tracked .agents/skills mirror. scripts/sync-skill-hosts.sh remains as a legacy wrapper for old local instructions; new docs should use scripts/validate-plugin.sh.

Requirements

  • Claude Code and/or Codex
  • Ruby (for skill frontmatter validation; no gems required)
  • jq (for JSON manifest validation in scripts/validate-plugin.sh)
Ver o original no GitHub

Bom para

Relacionados