convez.ai
SkillDevOps & InfraestruturaAvançado
IamK77

Skill — Suites de Engenharia Gateadas para Claude Code

IamK77/Skill

Ciclos de engenharia gateados para agentes Claude — evita pulos de etapas críticas

Ver no GitHub
InicialPluginScore · de 0 a 100

Conjunto de três suites (engineering, distributed, inquiry) que implementam processos de engenharia em ciclos controlados por gates executados via CLI checklist. Cada suite organiza práticas humanas em procedimentos multi-estágio que agents Claude não podem pular, garantindo conformidade com etapas críticas de desenvolvimento, sistemas distribuídos e pesquisa computacional.

Instalação

$npx convez-ai IamK77/Skill

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
2
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 1 mês
Versão
v0.5.1
Issues abertas
0
Contribuidores
2

Casos de uso

  • Garantir que agentes sigam ciclo completo de desenvolvimento (requirements → testes → segurança → deploy)
  • Validar corretude em sistemas distribuídos com checklist de verificação obrigatória
  • Estruturar pesquisa computacional com gates que impedem progresso sem documentação completa

Veredito

Ferramenta madura e bem-pensada para quem trabalha com agentes em workflows críticos. O modelo de gates executados por CLI é elegante e resolve um problema real — agentes pulando etapas — mas exige disciplina organizacional e só vale em projetos que justificam esse overhead.

README

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

Skill — gated skill suites for Claude Code

Agents now write much of the code, and they do not reliably repeat process steps unless something enforces them. Each skill here moves one piece of human-era practice into a form an agent-assisted workflow can follow: a multi-stage procedure whose stage gates are machine-enforced by the checklist CLI — the agent cannot skip ahead, and cannot close a stage without recording every check. Three suites, each installable as one Claude Code plugin: engineering (the software lifecycle, its security, and the craft of the code itself), distributed (correctness for systems that span machines), and inquiry (computational research that survives review — from a vague area to published results).

Quickstart

npm install -g @iamk77/skill-checklist   # the CLI that enforces every gate — without it a skill stops at its first command
/plugin marketplace add IamK77/Skill
/plugin install engineering@skill
/plugin install distributed@skill
/plugin install inquiry@skill

First run: have existing code? /engineering:assay path/to/module — it works on any module and audits the tests you already have. Starting something new? /engineering:groundwork <the-feature>. Not sure which skill fits? /engineering:pilot <your task> routes you — or tells you when no skill is needed.

Plugin-provided skills are prefixed by their plugin name — /engineering:plumb, /distributed:holdfast; bundling each suite into one plugin makes the prefix a meaningful namespace. To use a skill without plugins instead, copy skills/<suite>/<name>/ (e.g. skills/engineering/assay/) into ~/.claude/skills/ (personal) or .claude/skills/ (per-project), keep the checklist CLI on PATH, and drop the prefix: /assay path/to/module.

What a gated run looks like

Every skill walks its stages in order, and the CLI refuses to open a stage until every check in every prior stage is recorded as pass. From a real assay session (stages are addressed by name, never by number; a refused gate exits non-zero):

$ checklist init $CLAUDE_SKILL_DIR --force
checklist ready, 8 phases
  0: charter (1 checks)
  1: survey (1 checks)
  ...

$ checklist verify survey                       # try to skip ahead
gate blocked: PHASE 0 (charter) incomplete

$ checklist check charter motivation-identified
[x] motivation-identified .. confirmed

$ checklist verify charter
PHASE 0: CHARTER

1. [x] motivation-identified .................... confirmed

PHASE 0 verified, proceed to PHASE 1            # now survey opens

The engineering suite

Ten skills covering the engineering lifecycle, its security, and the craft of the code itself. The lifecycle runs groundwork → load-bearing → flightline → assay → stationkeeping → husbandry, with gauge (feedback), the aegis / gungnir security pair (shield & spear), and plumb (code craft) cross-cutting. A separate un-gated navigator, pilot, sits in front of them all: tell it your task and it routes you to the right skill(s) in the right order — or says plainly when no skill is needed.

SkillLifecycle roleStages
pilotNavigator (un-gated front door) — routes a task to the right skill(s), or says none is needed—
groundworkRequirements — pin down what to build before building it5
load-bearingArchitecture — style, stack, boundaries, contracts, data model6
flightlineEngineering process — version control, review, CI/CD, dependencies6
assayTesting — what to test, how, and proving the suite can fail8
stationkeepingOperations — deploy & release, observability, monitoring, SLOs & incidents, capacity, DR7
husbandryMaintenance & evolution — debt, refactoring, defects, versioning, dependencies, legacy, retirement6
gaugeFeedback surface (cross-cutting) — strict types, boundary validation, legible failures5
aegisSecurity (cross-cutting, the shield) — threat modeling, secure design & coding, SAST/DAST/SCA, OWASP defenses6
gungnirAdversarial validation (the spear) — authorized pentest: scope, recon, exploit, chain, fix & re-test6
plumbCode craft (cross-cutting, the plumb line) — naming, functions, abstraction, trust-chains, smells, testability6

Every gated skill is a directory — SKILL.md + a references/ library + a .checklist.yml gate definition (the navigator pilot is un-gated, so it carries no .checklist.yml). No build, no package step. Each section below links to the skill's directory; the stage tables live there.

pilot

pilot is the navigator — the front door to the suite. It is a dispatcher, not a methodology, so it has no gates: tell it a task, a goal, or just a confusion, and it returns a routing verdict — run this skill, run these in this order, or don't reach for a skill, here's why. Its value is the four things a trigger-match can't do: sequence a multi-skill job, redirect ("you asked for a review, but there are no tests yet — start with assay"), refuse when no skill is warranted, and disambiguate the confusable pairs (plumb vs gauge, assay vs gauge, flightline vs husbandry, aegis vs gungnir). Before sending you into a gated skill it checks that the checklist CLI is installed.

Invoke with /engineering:pilot <the-task-to-route> · map and references: skills/engineering/pilot/

groundwork

groundwork is the requirements work that comes before code. It resists the agent's strongest instinct — implement the literal ask — and instead pins down what is actually worth building. Its output is a requirements baseline — the contract the build, and later assay's tests, honor.

Invoke with /engineering:groundwork <feature-or-change-to-scope> · stages and references: skills/engineering/groundwork/

load-bearing

load-bearing designs architecture for the agent-assisted era. Architecture is the set of decisions that are expensive to reverse — so the skill triages every decision into a one-way door (data schema, public contract, trust model, the split into services) that earns real human judgment and an ADR, or a two-way door that gets a default and is left for agents to refactor freely. Its output is the architecture (boundaries, contracts, data model) and the ADRs the build honors.

Invoke with /engineering:load-bearing <system-or-change-to-architect> · stages and references: skills/engineering/load-bearing/

flightline

flightline sets up or hardens a project's engineering process so quality is an automated floor that holds for everyone, instead of something each contributor has to remember. The agent era makes this the whole game: the most prolific contributor is an agent with no self-discipline, so every quality property not encoded as a hard, un-gameable gate is one it will eventually violate while looking successful.

Invoke with /engineering:flightline <project-or-practice-area> · stages and references: skills/engineering/flightline/

assay

assay drives testing through a risk-driven decision tree: what is worth testing, which test type, which test double, and which cases actually catch bugs. A green suite is worthless until it has proven it can go red — so the skill drives a defect through its whole life. Shown in full as the one worked example — every other skill follows the same shape:

StageDoes
CharterFix what this testing is hired to do (bug-fix, refactor-safety, defect hunt, load-hardening, pre-release, suite audit, general confidence)
SurveyMap the testable surface — entry points, untrusted edges, collaborators, side effects, existing coverage
TriageBuild a ranked risk ledger (likelihood × blast-radius × detection-gap) and an explicit DO-NOT-TEST list
ChoosePer risk: test type and scope, example vs property, the weakest sufficient double, determinism guards
ComposeTurn each risk into cases with a named oracle; design second-invocation cases for stateful units
BuildWrite and run the tests; build determinism in by construction; apply the language's norms and must-run commands
BiteProve the suite can go red — mutation or a deliberate break — audit single-call tests, sweep for test smells
BooksDispose of every bug found (fix / file-and-defer / pin); close the non-functional-requirement loop

Invoke with /engineering:assay <path/to/module> · stages and references: skills/engineering/assay/

stationkeeping

stationkeeping is the operations work that begins where a green pipeline ends: software's life is in production, not the repository — and most outages are not logic bugs but deployment, configuration, capacity, or dependency failures that only exist once the system is live. It holds a running system on station — against drift, failure, load, and attack — tuned for a world where an agent operates production and reads a green dashboard as safety and silence as health.

Invoke with /engineering:stationkeeping <service-or-system-to-operate> · stages and references: skills/engineering/stationkeeping/

husbandry

husbandry is the maintenance-and-evolution work the whole lifecycle is really a down-payment on: maintenance is 60–80% of a system's total cost, and software is read and changed far more than it is written. So it treats software not as a building you finish but as a living thing to keep cheaply changeable — tuned for a world where an agent does the maintaining and reaches for a rewrite, banks debt invisibly, refactors without a net, and rots the docs.

Invoke with /engineering:husbandry <system-or-module-to-maintain> · stages and references: skills/engineering/husbandry/

gauge

gauge engineers a codebase's feedback surface so an agent gets clear feedback at every step — fast, local, attributed, deterministic, trustworthy, un-fakeable — instead of flailing against late, opaque, or false-green signals. It is the medium, not a lifecycle phase: it makes the code emit clear signal and leans on its siblings for depth.

Invoke with /engineering:gauge <project-or-module> · stages and references: skills/engineering/gauge/

aegis

aegis is the shield: it weaves security through the whole lifecycle instead of bolting it on at the end — because the worst weaknesses are architectural and can't be patched in later. It is cross-cutting like gauge, owning the security line and directing the siblings (SAST/secret-scan in flightline, runtime defense in stationkeeping).

Invoke with /engineering:aegis <system-or-scope-to-secure> · stages and references: skills/engineering/aegis/

gungnir

gungnir is the spear that proves the shield: authorized, adversarial penetration testing of a system you own or have written permission to test, to find the holes while they're still cheap to fix. Its first gate is absolute — you attack only authorized targets, never anything else. Authorized use only — your own or explicitly-permitted systems.

Invoke with /engineering:gungnir <your-own-or-authorized-target> · stages and references: skills/engineering/gungnir/

plumb

plumb is the plumb line you hold against code to see whether it is true: a cross-cutting craft / legibility lens. Its thesis is the oldest in the craft — code is written for humans to read, and only incidentally for a machine to run — and its goal is boring: simple, clear, predictable code that the next reader (now usually an agent session with no context) gets at a glance. It owns the legibility line and routes fixes to its siblings (types to gauge, refactors to husbandry, tests to assay).

Invoke with /engineering:plumb <code-to-audit> · stages and references: skills/engineering/plumb/

The distributed suite

Where the engineering suite is general software practice, the distributed suite is for systems that span machines — where partial failure, an unreliable asynchronous network, and the absence of a global clock make "correct" genuinely hard.

SkillRoleStages
holdfastDistributed correctness — partial failure, communication, ordering, replication, consensus, sharding, fault tolerance, coordination8

holdfast

holdfast is the distributed-correctness lens — the realities a single-machine programmer (and an agent) gets wrong by default. The one shift it installs is the third state: a remote call can succeed, fail, or leave you not knowing which — and single-machine code has no branch for "I don't know," which is where most distributed bugs live. Its eight stages are eight facets of one problem — surviving partial failure, an asynchronous unreliable network, and the absence of a global clock or state: frame · communication · ordering · replication · consensus · sharding · fault tolerance · coordination.

Invoke with /distributed:holdfast <design-or-code> · stages and references: skills/distributed/holdfast/

The inquiry suite

Where the engineering and distributed suites are about building software, the inquiry suite is about doing computational research — the work of going from a vague area to published results in any field where you run experiments to publish (machine learning, combinatorial optimization, operations research, systems, scheduling). It updates human-era research practice for a world where the agent does the searching, reading, reproducing, and drafting — and therefore fools you by default, optimizing for output that looks like a result. Three skills so far form a pipeline over the first three research steps, each handing the next a concrete artifact: prospect (find and prove the gap) → crucible (forge the method) → ledger (design the experiments).

SkillRoleStages
prospectResearch-gap prospecting — bound the ground, mine candidate gaps in parallel, attack & rank, kill cheaply, land the gap6
crucibleMethod design — decidable spec, oracle ceiling, race death-orthogonal variants in a feasibility-checked tournament, deepen with theory / ablation / novelty7
ledgerExperiment design — claim-evidence matrix, exploration/confirmation firewall, instances & fair baselines, statistics, ablation & sensitivity, frozen protocol7

prospect

prospect owns step one of research — choosing what to work on, and proving it is worth working on. The one shift it installs is mine, don't read: a gap is not read out of the literature by close-reading until an idea "emerges", it is mined out by a fixed set of extraction strategies (the seven seams — limitation-clustering, the cross-blank matrix, assumption-audit, leaderboard-weakness, reproduction-arbitrage, cross-domain transplant, trend arbitrage) run in parallel, then made to survive an adversarial "prove this was already done" attack before you bet on it. The agent is the means — the parallel miner and the adversary — never the oracle; you keep three judgments it cannot have (how to slice the dimensions, why a blank is blank, which gap to bet on). Its six stages — frame · mine · filter · rank · kill · land — end in the three deliverables that mean the literature review is done: a one-page gap statement, a core-paper comparison table, and 1–2 baselines reproduced on your machine.

Invoke with /inquiry:prospect <area-to-prospect-or-gap-to-stress-test> · stages and references: skills/inquiry/prospect/

crucible

crucible owns step two — turning a landed gap into a method worth writing up. The one shift it installs is a method is raced to death, not nursed: where implementing a variant once cost weeks (so you bet on one idea and grew attached to it), a cheap agent prototype of each variant lets you generate several and run an elimination tournament against kill criteria written before the race — on a scaffold whose independent feasibility checker traps the agent's silent bugs (a variant that "soars" is usually emitting infeasible solutions). You measure the prize first with an oracle ladder (total gap = is the direction worth it; per-level gaps = which component to attack), then deepen the survivor with theory (counterexample-search-first, the proof-laundering guard), pre-wired ablation switches, and a mechanism-keyword novelty defense. Its seven stages: spec · ceiling · variants · tournament · theory · ablation · novelty.

Invoke with /inquiry:crucible <gap-to-turn-into-a-method-or-method-to-stress-test> · stages and references: skills/inquiry/crucible/

ledger

ledger owns step three — turning a forged method into evidence a reviewer believes. The one shift it installs is write down what counts as evidence before you look at the data: the protocol (claims, instances, baselines, metrics, and the conditions that count as support or refutation) is frozen before the main run, because running first and choosing the story after is the experiment-version of p-hacking. Its keystone is a firewall between exploration and confirmation — chaos-testing an MVP generates hypotheses into an append-only notebook whose numbers never enter the paper, and confirmation re-runs the survivors on fresh seeds and instances under the frozen protocol. The agent is the experiment operator (batch-submit, monitor, auto-retry, summarize), never the judge of what the numbers mean. Its seven stages: matrix · firewall · instances · baselines · stats · ablation · freeze.

Invoke with /inquiry:ledger <method-to-design-experiments-for-or-protocol-to-stress-test> · stages and references: skills/inquiry/ledger/

checklist

checklist is a TypeScript CLI (npm: @iamk77/skill-checklist, built on commander). It loads a skill's .checklist.yml, tracks per-stage pass/fail state in the skill directory, and refuses to open a stage until every check in every prior stage is recorded as pass — not merely present. A check that regresses on re-verify overwrites a stale pass, so the gate reflects current state. (checklist calls these units phases; the skills present them to the user as stages — they are the same thing.)

npm install -g @iamk77/skill-checklist

The enforcement model, plainly: today every shipped skill's checks are manual human-judgment confirmations — the CLI's teeth are the ordered prior-stage gate plus regress-overwrites-stale-pass. Mechanical verify rules (builtin: / shell: / script:) exist and are tested, but no shipped skill uses them yet.

The published package ships a compiled dist/ build run through Node directly (no tsx, no install-time compile); runtime deps are commander, gray-matter, and js-yaml; requires Node >= 18. Released via release-please from Conventional Commits, backed by a 400+-test vitest suite — current version: see CHANGELOG and Releases.

To run it from a clone instead, cd Skill/devtools/checklist && npm install && npm run build && npm link. Full command reference, directory-resolution rules, the .checklist.yml schema, and the verify rule kinds: devtools/checklist/README.md.

Repository layout

skills/
  engineering/                                                       # the engineering suite
    pilot/                                                           # navigator (un-gated front door)
    groundwork/  load-bearing/  flightline/  assay/  stationkeeping/
    husbandry/   gauge/         aegis/       gungnir/  plumb/
  distributed/                                                       # the distributed suite
    holdfast/
  inquiry/                                                           # the inquiry suite
    prospect/  crucible/  ledger/
                 # each gated skill: SKILL.md  references/  .checklist.yml  LICENSE  NOTICE
                 # pilot (un-gated): SKILL.md  references/  LICENSE  NOTICE
devtools/
  checklist/             # the gate CLI (see its own README)
.claude-plugin/
  marketplace.json       # registers the repo as a Claude Code plugin marketplace
LICENSE  NOTICE

License

Apache-2.0, Copyright 2026 IamK77. See LICENSE and NOTICE.

Ver o original no GitHub

Bom para

Relacionados