Fetches hqq-quantization from davila7/claude-code-templates and configures it for Cursor.
3
Select Cursor when prompted
The CLI shows a list of agents. Use arrow keys and space to select Cursor:
◆ Which agents do you want to install to?
│
│ ── Universal (.agents/skills) ────────────────
│ · Cline · Codex · Goose · Windsurf
│ ●Cursor(selected)
│ · Cursor · Aider · Continue
4
Verify installation
Confirm successful installation by checking the skill directory location:
.cursor/skills/hqq-quantization
Restart Cursor to activate hqq-quantization. Access via /hqq-quantization in your agent's command palette.
⚠
Security Notice
We perform automated surface-level scans (Gen AI Scanner, Socket, Snyk) during installation. These checks detect common vulnerabilities but do not guarantee complete security. Always review skill source code and verify the publisher's reputation before production use.
Skills execute code in your environment. Always review source, verify the publisher, and test in isolation before production.
from hqq.core.quantize import BaseQuantizeConfig, HQQLinear
import torch.nn as nn
# Configure quantizationconfig = BaseQuantizeConfig( nbits=4,# 4-bit quantization group_size=64,# Group size for quantization axis=1# Quantize along output dimension)# Quantize a linear layerlinear = nn.Linear(4096,4096)hqq_linear = HQQLinear(linear, config)# Use normallyoutput = hqq_linear(input_tensor)
Quantize full model with HuggingFace
from transformers import AutoModelForCausalLM, HqqConfig
# Configure HQQquantization_config = HqqConfig( nbits=4, group_size=64, axis=1)# Load and quantizemodel = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B", quantization_config=quantization_config, device_map="auto")# Model is quantized and ready to use
Core concepts
Quantization configuration
HQQ uses BaseQuantizeConfig to define quantization parameters:
from hqq.core.quantize import BaseQuantizeConfig
# Standard 4-bit configconfig_4bit = BaseQuantizeConfig( nbits=4,# Bits per weight (1-8) group_size=64,# Weights per quantization group axis=1# 0=input dim, 1=output dim)# Aggressive 2-bit configconfig_2bit = BaseQuantizeConfig( nbits=2, group_size=16,# Smaller groups for low-bit axis=1)# Mixed precision per layer typelayer_configs ={"self_attn.q_proj": BaseQuantizeConfig(nbits=4, group_size=64),"self_attn.k_proj": BaseQuantizeConfig(nbits=4, group_size=64),"self_attn.v_proj": BaseQuantizeConfig(nbits=4, group_size=64),"mlp.gate_proj": BaseQuantizeConfig(nbits=2, group_size=32),"mlp.up_proj": BaseQuantizeConfig(nbits=2, group_size=32),"mlp.down_proj": BaseQuantizeConfig(nbits=4, group_size=64),}
HQQ supports multiple inference backends for different hardware:
from hqq.core.quantize import HQQLinear
# Available backendsbackends =["pytorch",# Pure PyTorch (default)"pytorch_compile",# torch.compile optimized"aten",# Custom CUDA kernels"torchao_int4",# TorchAO int4 matmul"gemlite",# GemLite CUDA kernels"bitblas",# BitBlas optimized"marlin",# Marlin 4-bit kernels]# Set backend globallyHQQLinear.set_backend("torchao_int4")# Or per layerhqq_layer.set_backend("marlin")
Backend selection guide:
Backend
Best For
Requirements
pytorch
Compatibility
Any GPU
pytorch_compile
Moderate speedup
torch>=2.0
aten
Good balance
CUDA GPU
torchao_int4
4-bit inference
torchao installed
marlin
Maximum 4-bit speed
Ampere+ GPU
bitblas
Flexible bit-widths
bitblas installed
HuggingFace integration
Load pre-quantized models
from transformers import AutoModelForCausalLM, AutoTokenizer
# Load HQQ-quantized model from Hubmodel = AutoModelForCausalLM.from_pretrained("mobiuslabsgmbh/Llama-3.1-8B-HQQ-4bit", device_map="auto")tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B")# Use normallyinputs = tokenizer("Hello, world!", return_tensors="pt").to(model.device)outputs = model.generate(**inputs, max_new_tokens=50)
Quantize and save
from transformers import AutoModelForCausalLM, HqqConfig
# Quantizeconfig = HqqConfig(nbits=4, group_size=64)model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B", quantization_config=config, device_map="auto")# Save quantized modelmodel.save_pretrained("./llama-8b-hqq-4bit")# Push to Hubmodel.push_to_hub("my-org/Llama-3.1-8B-HQQ-4bit")
Mixed precision quantization
from transformers import AutoModelForCausalLM, HqqConfig
# Different precision per layer typeconfig = HqqConfig( nbits=4, group_size=64,# Attention layers: higher precision# MLP layers: lower precision for memory savings dynamic_config={"attn":{"nbits"
✓
Make data-driven prioritization decisions faster
Stakeholder Communication
Draft PRDs, status updates, and stakeholder presentations
›Access to product documentation and roadmap tools (Jira, Notion, etc.)
›Understanding of product management frameworks (RICE, Jobs-to-be-Done, etc.)
›Stakeholder contact information and communication channels
Time Estimate
30-60 minutes to see productivity improvements
Steps
1Install product management skill
2Start with user story generation for known feature
3Progress to competitive analysis: research 2-3 competitors
4Use for roadmap prioritization: apply RICE/ICE scoring
5Draft stakeholder communications and refine based on feedback
6Build template library for recurring PM tasks
7Share effective prompts with product team
Common Pitfalls
⚠Not validating competitive research—verify facts before sharing
⚠Accepting user stories without involving engineering team
⚠Over-relying on frameworks without qualitative judgment
⚠Not customizing outputs to company culture and communication style
⚠Skipping stakeholder validation of generated requirements
Best Practices
✓ Do
+Validate research and competitive analysis with real data
+Collaborate with engineering when generating technical requirements
+Customize frameworks and templates to your company context
+Use skill for first drafts, refine with stakeholder input
+Document successful prompt patterns for PM tasks
+Combine AI efficiency with human judgment and intuition
✗ Don't
−Don't publish competitive analysis without fact-checking
−Don't finalize user stories without engineering review
−Don't make prioritization decisions solely on AI scoring
−Don't skip customer validation of generated requirements
−Don't ignore company-specific context and culture
💡 Pro Tips
★Provide context: company goals, constraints, customer feedback
★Ask for alternatives: 'Show 3 ways to prioritize this roadmap'
★Request stakeholder-specific formatting: 'Executive summary vs. engineering spec'
★Use skill for 70% generation + 30% customization to company needs
When to Use This
✓ Use when
Use for user story writing, competitive research, roadmap prioritization, stakeholder communication, and PRD drafting. Best for reducing repetitive documentation and research work.
✗ Avoid when
Avoid for strategic product vision (requires deep customer empathy), pricing decisions (needs market and financial expertise), or when face-to-face customer discovery is more valuable than speed.
Learning Path
1Basic: user stories, feature specs, status updates
