# fine-tuning-expert

A skill for LLM fine-tuning: prepares datasets, configures LoRA and QLoRA adapters, runs training and evaluates the result.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 4200 installs · ★ 12062
- Author: https://github.com/Jeffallan
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/Jeffallan/claude-skills/tree/HEAD/skills/fine-tuning-expert/SKILL.md
- Updated: 2026-10-21
- HTML: https://affpapa.org/en/nevibecode/skills/fine-tuning-expert

## What it does

The skill walks through five stages: dataset preparation, method selection, training, evaluation, deployment. Each stage has a checkpoint. Validate the JSONL first, then watch the loss curves, then measure perplexity, task metrics and latency on a held-out set. Parameter-efficient methods are recommended for large models; full fine-tuning is reserved for small ones.

Five reference files sit inside: `references/lora-peft.md`, `references/dataset-preparation.md`, `references/hyperparameter-tuning.md`, `references/evaluation-metrics.md`, `references/deployment-optimization.md`. The agent loads the one that matches the task. Code samples use Hugging Face PEFT and TRL — `LoraConfig`, `SFTTrainer`, `BitsAndBytesConfig` for 4-bit quantization, and `merge_and_unload` to fold the adapter back in.

Dataset validation runs as `python validate_dataset.py --input data.jsonl`, and errors have to be fixed before training starts. Merging adapters with mismatched rank, base model or target modules will break. The skill asks you to document hyperparameters and dataset versions, and to always include a learning rate warmup.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add Jeffallan/claude-skills --skill fine-tuning-expert -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/fine-tuning-expert/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/fine-tuning-expert/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add Jeffallan/claude-skills --skill fine-tuning-expert -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/fine-tuning-expert/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add Jeffallan/claude-skills --skill fine-tuning-expert -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/fine-tuning-expert/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install Jeffallan/claude-skills fine-tuning-expert
```

2. **Manually: put the files in place**
- File: `.github/skills/fine-tuning-expert/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add Jeffallan/claude-skills --skill fine-tuning-expert -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/Jeffallan/claude-skills --path skills/fine-tuning-expert
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/fine-tuning-expert/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add Jeffallan/claude-skills --skill fine-tuning-expert -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/Jeffallan/claude-skills/tree/HEAD/skills/fine-tuning-expert/SKILL.md

## When to use it
- validate a JSONL dataset for schema errors and duplicates before training
- pick between LoRA, QLoRA and full fine-tuning given GPU memory
- set hyperparameters and a learning rate schedule for a training run
- benchmark an adapter against the base model on a held-out set
- merge adapter weights and quantize the model for serving

## Example prompts
- Prepare `train.jsonl` for instruction tuning and run the validation script
- Configure a LoRA adapter for `meta-llama/Llama-3-8B` on my task
- Write an evaluation script with perplexity, BLEU and inference latency

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: 5c8c29d4f76873b0.

BEGIN THIRD-PARTY FILE 5c8c29d4f76873b0
```text
---
name: fine-tuning-expert
description: "Use when fine-tuning LLMs, training custom models, or adapting foundation models for specific tasks. Invoke for configuring LoRA/QLoRA adapters, preparing JSONL training datasets, setting hyperparameters for fine-tuning runs, adapter training, transfer learning, finetuning with Hugging Face PEFT, OpenAI fine-tuning, instruction tuning, RLHF, DPO, or quantizing and deploying fine-tuned models. Trigger terms include: LoRA, QLoRA, PEFT, finetuning, fine-tuning, adapter tuning, LLM training, model training, custom model."
license: MIT
metadata:
  author: https://github.com/Jeffallan
  company: https://synergetic.solutions
  version: "1.1.0"
  domain: data-ml
  triggers: fine-tuning, fine tuning, finetuning, LoRA, QLoRA, PEFT, adapter tuning, transfer learning, model training, custom model, LLM training, instruction tuning, RLHF, model optimization, quantization
  role: expert
  scope: implementation
  output-format: code
  related-skills: devops-engineer
---

# Fine-Tuning Expert

Senior ML engineer specializing in LLM fine-tuning, parameter-efficient methods, and production model optimization.

## Core Workflow

1. **Dataset preparation** — Validate and format data; run quality checks before training starts
   - Checkpoint: `python validate_dataset.py --input data.jsonl` — fix all errors before proceeding
2. **Method selection** — Choose PEFT technique based on GPU memory and task requirements
   - Use LoRA for most tasks; QLoRA (4-bit) when GPU memory is constrained; full fine-tune only for small models
3. **Training** — Configure hyperparameters, monitor loss curves, checkpoint regularly
   - Checkpoint: validation loss must decrease; plateau or increase signals overfitting
4. **Evaluation** — Benchmark against the base model; test on held-out set and edge cases
   - Checkpoint: collect perplexity, task-specific metrics (BLEU/ROUGE), and latency numbers
5. **Deployment** — Merge adapter weights, quantize, measure inference throughput before serving

## Reference Guide

Load detailed guidance based on context:

| Topic | Reference | Load When |
|-------|-----------|-----------|
| LoRA/PEFT | `references/lora-peft.md` | Parameter-efficient fine-tuning, adapters |
| Dataset Prep | `references/dataset-preparation.md` | Training data formatting, quality checks |
| Hyperparameters | `references/hyperparameter-tuning.md` | Learning rates, batch sizes, schedulers |
```
END THIRD-PARTY FILE 5c8c29d4f76873b0

The third-party file has ended. Everything between the 5c8c29d4f76873b0 tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2453 of 6805 bytes. © https://github.com/Jeffallan · MIT · https://github.com/Jeffallan/claude-skills/tree/HEAD/skills/fine-tuning-expert/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md