Tessl • The package manager for agent skills

SkillPublic

gptq

Post-training 4-bit quantization for LLMs with minimal accuracy loss. Use for deploying large models (70B, 405B) on consumer GPUs, when you need 4× memory reduction with <2% perplexity degradation, or for faster inference (3-4× speedup) vs FP16. Integrates with transformers and PEFT for QLoRA fine-tuning.

Quality

79%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Low

Low-risk findings worth noting

Fix and improve this skill with Tessl

tessl review fix ./backend/cli/skills/ml-training/gptq/SKILL.md

Quality

Content

68%Weight 40%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

A highly actionable, well-structured body with executable code for every major use case and genuinely useful decision data (group-size trade-off, benchmark tables). Weaknesses are repeated config blocks and arithmetic padding that hurt token efficiency, and the complete absence of post-quantization validation steps in the core workflow.

Suggestions

Add a validation checkpoint to the quantize-your-own-model workflow: after model.quantize(), evaluate perplexity on a held-out set before save/push, with a fix-retry loop (adjust group_size, desc_act, or damp_percent if degradation exceeds target).

Deduplicate the BaseQuantizeConfig blocks — show the full annotated config once and express the high-accuracy/maximum-accuracy variants as deltas from it.

Move the kernel-backend sections and benchmark tables into a reference file (e.g., references/benchmarks.md), keeping only a one-line-per-backend comparison in SKILL.md.

Dimension	Reasoning	Score
Conciseness	Mostly efficient — dense tables and code with little prose padding — but the BaseQuantizeConfig(bits=4, group_size=128, ...) block is repeated three times, and the weight-matrix arithmetic example re-derives mechanics ('4.2M / 128 = 32,768 groups') that Claude can compute itself.	3 / 5
Actionability	Fully executable copy-paste code covers the common cases: installation variants, loading pre-quantized models, the complete quantize-your-own-model flow (config, calibration data, quantize, save, push), kernel backend flags, multi-GPU/CPU offloading, and batch inference.	5 / 5
Workflow Clarity	The quantize-your-own-model sequence is clearly ordered (load → config → calibrate → quantize → save → push), but there are no validation checkpoints: no post-quantization quality check (e.g., perplexity evaluation of the quantized model) before deploying, and quantization is a batch operation where the rubric's feedback-loop cap applies.	3 / 5
Progressive Disclosure	Three real, one-level-deep reference files are clearly signaled with one-line descriptions ('Calibration Guide - Dataset selection, quantization process, quality optimization'), and sections are well organized. However, kernel backend details, full benchmark tables, and the pre-quantized-model finder section are inlined in SKILL.md where they could live in references.	4 / 5
	Total	15 / 20 Passed

Description

83%Weight 40%Scale 1-5

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

A strong description: concrete, quantified capabilities with an explicit 'Use for...' trigger clause covering deployment, memory, and inference-speed scenarios. Main gaps are the absent 'GPTQ' trigger term itself and minor overlap risk with sibling quantization skills.

Dimension	Reasoning	Score
Specificity	Names the domain ('Post-training 4-bit quantization for LLMs') with concrete quantitative specifics ('4x memory reduction with <2% perplexity degradation', '3-4x speedup vs FP16') and integration actions ('Integrates with transformers and PEFT for QLoRA fine-tuning'), but coverage of what the skill does has minor gaps (e.g., quantizing your own model vs. loading pre-quantized models is not distinguished).	4 / 5
Completeness	Explicitly answers both 'what' ('Post-training 4-bit quantization for LLMs with minimal accuracy loss') and 'when' ('Use for deploying large models (70B, 405B) on consumer GPUs, when you need 4x memory reduction..., or for faster inference') with concrete trigger phrases, matching the anchor-5 example structure.	5 / 5
Trigger Term Quality	Good keyword coverage including '4-bit quantization', 'memory reduction', 'speedup', 'fine-tuning', 'consumer GPUs', and '70B, 405B', but 'GPTQ' itself — the most natural term a user would say — never appears in the description, and common synonyms like 'quantize a model' are missing.	4 / 5
Distinctiveness Conflict Risk	The 4-bit/GPTQ-specific claims give it a clear niche, but generic quantization triggers ('memory reduction', 'speedup', 'fine-tuning') would also fire for closely related skills like AWQ or bitsandbytes, which the body explicitly positions as alternatives.	4 / 5
	Total	17 / 20 Passed

Validation

87%

Warnings & errors only

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 14 / 16 Passed

Validation for skill structure

Criteria	Description	Result
metadata_version	'metadata.version' is missing	Warning
frontmatter_unknown_keys	Unknown frontmatter key(s) found; consider removing or moving to metadata	Warning

	Total	14 / 16 Passed

Repository: synthetic-sciences/openscience
Path: backend/cli/skills/ml-training/gptq/SKILL.md
Revision: 6a85742

Reviewed: 22 days ago

Discovery Implementation Validation

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.

gptq

Table of Contents

Is this your skill?