convez.ai
SkillProdutividadeIntermediário
gleicon

DevSkills

gleicon/devskills

Comandos de dev com controle total do usuário, do spec ao produto

Ver no GitHub
BomPluginScore · de 0 a 100

Pacote de comandos instaláveis para Claude Code, OpenCode, Cursor e VSCode Copilot que oferece padrões opinados e fluxo completo de desenvolvimento. Fornece comandos de linha de comando (/ds-*) que você invoca manualmente, mantendo total controle sobre quando cada ferramenta é executada, sem delegar autonomia ao modelo.

Instalação

$npx convez-ai gleicon/devskills

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
20
Forks
5
Acompanhando
2
Saúde
42%
Último commit
há 2 semanas
Versão
v0.10.0
Issues abertas
0
Contribuidores
3

Casos de uso

  • Padronizar workflows de desenvolvimento entre IDEs (Claude Code, Cursor, VSCode)
  • Executar verificações de segurança e debugging sob demanda com osv-scanner
  • Configurar baselines de engenharia em projetos com suporte multi-linguagem

Veredito

Ferramenta sólida para devs que querem aumentar produtividade com atalhos controlados. Abordagem honesta: não promete automação mágica, apenas coloca ferramentas de verdade sob seu comando.

README

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

devskills

Installable command pack for Claude Code, OpenCode, OpenAI Codex, Cursor, and VSCode Copilot. Opinionated defaults, composable language profiles, a full dev workflow from specification to shipped product.

Despite the name, this is not a Skills repo — it ships commands, not skills. A Claude Code Skill is invoked by the model whenever it decides one applies; a devskills command is a slash command you invoke, when you choose. That difference is the point: the tools stay under your control. devskills doesn't hand the model more autonomy — it sharpens your developer skills with tools you drive directly, and you keep total control over when each one runs.

No magic. Files in the right directories. Prompts that encode real constraints.

Install

git clone https://github.com/gleicon/devskills.git ~/.devskills
~/.devskills/install.sh

Commands copy to ~/.claude/commands/, ~/.opencode/commands/, and ~/.codex/prompts/ (each installed only when that tool is detected). External tools (osv-scanner, tldt) install automatically when their prerequisites are present (Homebrew or Go).

In Codex, devskills commands are invoked under the prompts: namespace — /ds-debug becomes /prompts:ds-debug. Codex reads a project's AGENTS.md natively, so setup.sh covers its persistent surface with no extra step.

Skip external tools:

~/.devskills/install.sh --skip-external

Custom Claude config dir:

~/.devskills/install.sh --claude-dir=~/.config/claude

Per-project setup (run from inside a project):

~/.devskills/scripts/setup.sh                        # baseline AGENTS.md only
~/.devskills/scripts/setup.sh --lang=go              # baseline + Go profile
~/.devskills/scripts/setup.sh --lang=typescript --cursor --vscode

setup.sh writes a universal engineering baseline to AGENTS.md and points CLAUDE.md at it via @AGENTS.md; --lang stacks a language profile on top. See Repository Setup below.

Keep devskills up to date:

~/.devskills/scripts/update.sh              # pull + reinstall commands
~/.devskills/scripts/update.sh --upgrade-deps  # also force-upgrade tldt

Renamed in this release: every command is now namespaced with a ds- prefix (e.g. /debug → /ds-debug), and modes carry a -mode suffix (e.g. /tiger-style → /ds-tiger-style-mode). This avoids collisions with Claude Code built-ins like /debug and /security-review, and makes a command's kind readable at a glance. Re-running install.sh or update.sh drops in the new names and removes the old files automatically — no manual cleanup. See the Commands table for the current names.

install.sh flags

--lang=<profile>     go | typescript | javascript | rust | python | java | zig
--claude-dir=<path>  Claude config dir (default: $CLAUDE_CONFIG_DIR or ~/.claude)
--skip-external      skip tldt installation
--skip-cursor        skip Cursor rules
--skip-vscode        skip VSCode Copilot instructions
--concise            add a terse-response directive to AGENTS.md (with --lang)
--dry-run            show what would happen, write nothing

setup.sh flags (per-project)

--lang=<profile>     optional; stacks a language profile (go|typescript|javascript|rust|python|java|zig)
--concise            add a terse-response directive to AGENTS.md
--cursor             install Cursor rules into current project
--vscode             install VSCode Copilot instructions into current project
--dry-run            show what would happen, write nothing

Commands

Every command is namespaced with a ds- prefix (short for devskills) so it never collides with a Claude Code or OpenCode built-in, and its suffix tells you its kind: -mode (persists for the session), -review (a findings-list audit), -plan (a graded, costed plan), or no suffix (a one-shot action). Full taxonomy and per-command detail are in docs/commands.md.

Modes — persistent session behavior (-mode)

CommandDescription
/ds-tiger-style-modeTigerBeetle engineering constraints: safety, performance, experience
/ds-ui-modeUI mode: component/state discipline, design craft, a11y, Core Web Vitals
/ds-data-modeData-engineering discipline: idempotency, late/out-of-order data, schema drift, replay/backfill safety, data-quality assertions
/ds-senior-modeWrite like a super-senior engineer in everything — terse, direct, no slop — across code, comments, commits, PRs, docs, and replies; folds in git + test + deslop + step discipline, works in small reviewable steps
/ds-git-modeSenior-engineer commit discipline: self-contained units, terse Conventional-Commit messages, branch-first, never rewrite history
/ds-step-modeUser-driven, step-gated execution — smallest step → stop → free-form handback → repeat
/ds-tdd-modeTest-first, one vertical slice at a time
/ds-test-modePragmatic testing — test by risk, not coverage
/ds-quality-gate-modeSeven-pass review pipeline (deslop → test → security → bug → data → quality → docs → deslop), fixes between passes
/ds-caveman-lite-modeCompressed response mode (~25–35% token reduction)
/ds-caveman-ultra-modeCompressed response mode (~75–85% token reduction)

Reviews — findings-list audits (-review)

Every -review reports by default and changes nothing; pass --fix to apply the mechanical, unambiguous findings in place.

General

CommandDescription
/ds-bug-reviewLanguage-agnostic correctness audit — hunts real bugs
/ds-security-reviewLanguage-agnostic security audit — each finding names the attack
/ds-osvScan dependency manifests for known CVEs via OSV Scanner; --fix bumps direct deps
/ds-data-reviewStore-agnostic data audit — schema/integrity, query correctness, transactions, migration safety (--pipelines for ETL)
/ds-code-reviewSingle-source-of-truth audit — duplicates, constant drift, parallel-agent conflicts, unjustified dependencies
/ds-code-quality-reviewStrict maintainability audit: abstraction, sprawl, spaghetti
/ds-doc-quality-reviewStrict docs audit: accuracy, dead links, bloat (--comments for code comments)
/ds-test-quality-reviewStrict test audit: is critical code well tested?
/ds-ui-quality-reviewStrict UI audit: async-state/fetch correctness, a11y, Core Web Vitals, design craft
/ds-comment-reviewWHY-not-WHAT comment discipline — strip restate/obvious/cruft, keep the rare important one

Language

CommandDescription
/ds-go-reviewGo: idiomatic + security + Tiger Style (--no-tiger to skip style)
/ds-ts-reviewTypeScript/Workers: strict mode, React, Cloudflare
/ds-rust-reviewRust: geiger/unsafe, clippy, audit, Tiger Style
/ds-python-reviewPython: idioms, typing, security, Tiger Style
/ds-java-reviewJava: idioms, records/sealed types, security, Tiger Style
/ds-zig-reviewZig: explicit allocators, errors-as-values, safety, Tiger Style
/ds-notebook-reviewJupyter: execution/hidden-state, committed outputs, reproducibility, data-science correctness

Plans — graded, sequenced moves (-plan)

CommandDescription
/ds-perf-planOptimization plan — moves tagged by architectural cost (L1/L2/L3), each with a cost model
/ds-architecture-planModule/dependency/boundary analysis → sequenced refactoring plan (L1/L2/L3)

Workflow & design

CommandDescription
/ds-specConvert a description into a structured specification
/ds-roadmapOrdered ## Roadmap task list from a goal, spec, or findings
/ds-exploreLay out candidate approaches with trade-offs (--web for research)
/ds-blueprintDesign a target architecture — modules, dependency rules, seams, build order
/ds-grill-meRelentless plan interview (--record logs to DECISIONS.md)
/ds-workflowPhase-map orchestrator — orient, then route each phase to its command

Project memory (.project/)

Minimal file-backed memory — keep state across /clear and session ends. Not required; opt-in.

CommandDescription
/ds-project-mapScan the repo into .project/PROJECT.md
/ds-project-checkpointPersist state to .project/PLAN.md (--handoff for a full handoff doc)
/ds-project-resumeRestore context from .project/PLAN.md

Debug & verification

CommandDescription
/ds-debugRoot-cause a failure with the scientific method
/ds-verify-thisProve a falsifiable claim with local before/after evidence
/ds-zoom-outStep up a layer — map modules, callers, boundaries

Utilities

CommandDescription
/ds-deslopStrip AI-generated slop from the branch diff
/ds-handoffCompact the conversation into a handoff doc
/ds-tldtExtractive summary of context or a file — no LLM cost
/ds-write-a-commandAuthor a new devskills command in repo conventions

Context recycling (experimental — requires recall)

Local-first context engine: indexes your project, accumulates cross-project recipes and insights, and routes questions to a local model before hitting the cloud API. Goal: reuse what you already paid for.

CommandDescription
/ds-recallIndex project + inject a context-rich brief into the session; query "<q>" routes locally; brain pulls cross-project patterns
/ds-recall-captureCompact this session's outcome (goal + result + insight) and store it in recall's knowledge base
/ds-recall-setupIndex project, seed recipes, and install recall's session integration via recall install-skill (claude; opencode/cursor/codex when present)

Build your own workflow

devskills ships no fixed pipeline. Each command does one job and hands control back — you compose them into whatever flow the work needs. Unlike all-in-one agent frameworks that drive the session for you, the power stays with you: nothing here decides your next step. Start anywhere, reorder freely — spec, plan, build under a mode or two, review, persist. The docs lay out worked flows, not one true path:

Repository Setup

setup.sh builds your project's AGENTS.md from stacked, independently-managed blocks, and points CLAUDE.md at it with a single @AGENTS.md import — so Claude Code (which reads CLAUDE.md) and OpenCode and OpenAI Codex (which read AGENTS.md directly) share the same content with no duplication.

BlockFlagContents
basealwaysUniversal engineering principles — think before coding, simplicity first, surgical changes, goal-driven execution, safe at the boundaries
language--lang=<x>Stack-specific idioms, toolchain, and review constraints
concise--conciseTerse-response directive (caveman-lite behavior, baked in)

Running setup.sh with no flags writes just the baseline. Each block lives between <!-- BEGIN/END devskills:<id> --> markers, so re-running is idempotent and swapping --lang replaces only that block. Existing AGENTS.md/CLAUDE.md files are backed up (sibling timestamped .bak) once, before any change — these are transient; delete them or keep them out of version control once you've confirmed the result.

update.sh refreshes the globally-installed commands, but not a project's AGENTS.md — the managed blocks are a point-in-time snapshot. To pull baseline changes into a project after an update, re-run setup.sh there (idempotent, so it just refreshes the blocks in place).

The baseline blocks target AGENTS.md (Claude Code, OpenCode, and OpenAI Codex). Cursor and VSCode Copilot have their own rule mechanisms — --cursor installs .cursor/rules/*.mdc and --vscode writes copilot-instructions.md. Both honor --lang: they carry Tiger Style plus the notes for the selected language only (no --lang writes Tiger Style alone), but not the base/concise blocks.

To back out, setup.sh --uninstall strips the devskills blocks (and removes a file that held only devskills content), leaving your own content untouched — a clean install→uninstall round-trip restores the originals exactly.

Language Profiles

Each profile encodes idioms, toolchain defaults, and review constraints for its stack, and is stacked under the baseline as a ## Language Profile — <x> section.

ProfileStackUse case
goGo 1.24+Backend services, CLIs, APIs
typescriptTypeScript 5+, WranglerCloudflare Workers, Next.js, React
javascriptES2022+, WranglerCloudflare Workers, vanilla frontend
rustRust stableSystems programming, large projects
pythonPython 3.13+Backend services, APIs, CLIs, data pipelines
javaJava 25+ (LTS)Backend services, APIs, CLIs, systems tooling
zigZig 0.16Systems programming, CLIs, embedded (Tiger Style native)

Scripts

install.sh — one-time global install. Copies commands to Claude Code and OpenCode config dirs. Installs external tools. Run from anywhere.

scripts/setup.sh — per-project configurator. Builds AGENTS.md (engineering baseline + optional language/concise blocks) and points CLAUDE.md at it via @AGENTS.md, optionally installs Cursor rules and VSCode Copilot instructions into the current directory. Run from inside a project. See Repository Setup.

scripts/update.sh — pulls the latest devskills repo and reinstalls skills. Use --upgrade-deps to also force-upgrade tldt to its latest published version.

scripts/upgrade-deps.sh — force-upgrades external tools regardless of current state. Useful after upstream major version bumps.

External Tools

Installed by install.sh. Managed by upgrade-deps.sh.

ToolPurpose
osv-scannerSupply-chain vulnerability scan against the OSV/CVE database
tldtExtractive text summarization; no LLM, no cost

References

devskills ships its own prompt commands based on these upstream sources.

ReferenceUsed by
Tiger Style/ds-tiger-style-mode, all review commands
Caveman/ds-caveman-lite-mode, /ds-caveman-ultra-mode
mattpocock/skills/ds-grill-me, /ds-handoff, /ds-zoom-out, /ds-tdd-mode, /ds-write-a-command
cursor/plugins — cursor-team-kit/ds-code-quality-review, /ds-deslop, /ds-verify-this
Andrej Karpathy · multica-ai/andrej-karpathy-skillsAGENTS.md baseline (base block)
recall/ds-recall, /ds-recall-capture, /ds-recall-setup

License

MIT — see LICENSE.

Ver o original no GitHub

Bom para

Relacionados