Skip to main content
skill CX Codex

ai-ml-development — Claude Code skill: what it does, how to install

ai-ml-development — a skill for Claude Code and Codex handling machine learning tasks. Activates when building training pipelines, fine-tuning LLMs, or assembling RAG applications.

MIT 167 installs ★ 114 updated 2026-11-10

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add travisjneuman/.claude --skill ai-ml-development -a claude-code
Open on GitHub

What ai-ml-development does

The skill guides agents through machine learning workflows across PyTorch, TensorFlow, JAX, and scikit-learn. Its root overview contains concrete PyTorch boilerplate, featuring an end-to-end ConvNet definition, an AdamW training loop, and a PyTorch Lightning module complete with metric logging.

Deep-dive guides live in standalone documents inside the references/ folder. They detail LoRA parameter-efficient fine-tuning via Hugging Face, vector search with Pinecone and ChromaDB, and model serving through FastAPI with MLflow tracking. LLM integration topics cover OpenAI and Anthropic SDK patterns, structured output schemas, and tool calling.

What it helps with

  • scaffold a PyTorch training and validation loop with AdamW
  • fine-tune language models with LoRA using Hugging Face
  • set up a retrieval pipeline with ChromaDB or Pinecone
  • deploy models using FastAPI and track artifacts in MLflow

Example prompts for the agent

  • Help me configure LoRA fine-tuning for a Hugging Face model
  • Write a PyTorch Lightning module for multiclass image classification
  • Implement structured output extraction using the Anthropic Claude API

How to install ai-ml-development

1Skills CLI (Vercel)

npx skills add travisjneuman/.claude --skill ai-ml-development -a claude-code

2Manually: put the files in place

~/.claude/skills/ai-ml-development/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/ai-ml-development/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about ai-ml-development

How to install ai-ml-development in Claude Code?

Run npx skills add travisjneuman/.claude --skill ai-ml-development -a claude-code in your terminal.

What does ai-ml-development do?

It provides architecture reference patterns and scripts for classic deep learning, MLOps, and LLM application engineering.

Where are the specialized guides for vector databases and MLOps stored?

They reside in the references/ folder and get read individually depending on whether you work on vector stores, MLflow, or model serving.

Source text

SKILL.md · MIT
---
name: ai-ml-development
description: AI and machine learning development with PyTorch, TensorFlow, and LLM integration. Use when building ML models, training pipelines, fine-tuning LLMs, or implementing AI features.
---

# AI & Machine Learning Development

Comprehensive guide for building AI/ML systems from prototyping to production.

## Frameworks Overview

| Framework        | Best For               | Ecosystem                  |
| ---------------- | ---------------------- | -------------------------- |
| **PyTorch**      | Research, flexibility  | Hugging Face, Lightning    |
| **TensorFlow**   | Production, mobile     | TFX, TF Lite, TF.js        |
| **JAX**          | High-performance, TPUs | Flax, Optax                |
| **scikit-learn** | Classical ML           | Simple, batteries-included |

---

## PyTorch

### Model Definition

```python
import torch
import torch.nn as nn
import torch.nn.functional as F

class ConvNet(nn.Module):
    def __init__(self, num_classes: int = 10):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(64 * 8 * 8, 256)
        self.fc2 = nn.Linear(256, num_classes)
        self.dropout = nn.Dropout(0.5)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 64 * 8 * 8)
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        return self.fc2(x)
```

### Training Loop

```python
from torch.utils.data import DataLoader
from torch.optim import AdamW
from tqdm import tqdm

def train_model(
    model: nn.Module,
    train_loader: DataLoader,
    val_loader: DataLoader,
    epochs: int = 10,
    lr: float = 1e-3,
    device: str = "cuda"
) -> dict:
    model = model.to(device)
    optimizer = AdamW(model.parameters(), lr=lr)
    criterion = nn.CrossEntropyLoss()

    for epoch in range(epochs):
        model.train()
        for batch in tqdm(train_loader):
            inputs, labels = batch[0].to(device), batch[1].to(device)
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()

        # Validation
        model.eval()
        correct = total = 0
        with torch.no_grad():
            for batch in val_loader:
                inputs, labels = batch[0].to(device), batch[1].to(device)
                outputs = model(inputs)
                _, predicted = outputs.max(1)
                total += labels.size(0)
                correct += predicted.eq(labels).sum().item()

        print(f"Epoch {epoch+1}: Val Acc {100.*correct/total:.2f}%")
```

### PyTorch Lightning

```python
import pytorch_lightning as pl
from torchmetrics import Accuracy

class LitModel(pl.LightningModule):
    def __init__(self, model: nn.Module, lr: float = 1e-3):
        super().__init__()
        self.model = model
        self.lr = lr
        self.criterion = nn.CrossEntropyLoss()
        self.accuracy = Accuracy(task="multiclass", num_classes=10)

    def training_step(self, batch, batch_idx):
        x, y = batch
        logits = self.model(x)
        loss = self.criterion(logits, y)
        self.log("train_loss", loss)
        return loss

    def validation_step(self, batch, batch_idx):
        x, y = batch
        logits = self.model(x)
        self.accuracy(logits, y)
        self.log("val_acc", self.accuracy)

    def configure_optimizers(self):
        return AdamW(self.parameters(), lr=self.lr)
```

---

## Reference files

Detailed material is in separate files so this overview stays short. Read only the file whose topic matches the task; each one is self-contained. Paths are relative to the folder that holds this `SKILL.md` (in the full toolkit install, `~/.claude/skills/ai-ml-development/`).

| Topic | File | Covers |
| --- | --- | --- |
| Hugging Face Transformers | [`references/hugging-face-transformers.md`](references/hugging-face-transformers.md) | Text Classification; Fine-Tuning LLMs with LoRA |
| LLM Integration | [`references/llm-integration.md`](references/llm-integration.md) | OpenAI API; Anthropic Claude API; LangChain |
| Vector Databases | [`references/vector-databases.md`](references/vector-databases.md) | Pinecone; ChromaDB (Local) |
| MLOps | [`references/mlops.md`](references/mlops.md) | Model Registry (MLflow); Model Serving (FastAPI) |
| Best Practices | [`references/best-practices.md`](references/best-practices.md) | Training; Deployment |
| LLM Application Development | [`references/llm-application-development.md`](references/llm-application-development.md) | RAG Architecture (Retrieval-Augmented Generation); Vector Databases; Prompt Engineering Patterns; Structured Outputs; Tool Use / Function Calling; Claude API / Anthropic SDK Patterns; and 3 more |

© travisjneuman · MIT · travisjneuman/.claude

Similar skills

All skills for AI and ML →

From the same set117

The whole set →
risk-management Enterprise risk management guidelines for assessing operational, tech, and vendor risks. Helps build heat maps and business continuity frameworks. CX Codex +1 171installs innovation An innovation-management playbook the agent can consult: horizons, portfolio mix, ideation, Stage-Gate, venture capital and IP. Handy when product bets need sorting. CX Codex +1 170installs api-design api-design is a Claude Code skill with guidelines and templates for REST, gRPC, and tRPC APIs; it helps generate OpenAPI schemas and keep route naming consistent. CX Codex +1 170installs generic-static-design-system generic-static-design-system — a design system skill for static sites built purely with HTML, CSS, and vanilla JS. Guides the agent to build lightweight interfaces without Tailwind or build tools. CX Codex +1 168installs flutter-development flutter-development — a skill for Claude Code provides project structure, Dart 3 patterns, and architecture guides across mobile, desktop, and web. Activates during Flutter app creation and Material Design implementation. CX Codex +1 166installs options-comparator options-comparator — a skill for Claude Code brings structured option comparison using weighted scoring matrices, trade-off analysis, and recommendation templates. Runs during vendor evaluations and strategy reviews. CX Codex +1 162installs accessibility-a11y accessibility-a11y — a skill for Claude Code and Codex guides WCAG 2.2 compliance and interface accessibility checks. Activates during UI component development, accessibility reviews, or CI/CD test integration. CX Codex +1 161installs literature-review-planner literature-review-planner plans an academic literature review: picks the review type, builds the search string, screens sources and lays out a PRISMA flow. CX Codex +1 160installs

Project sponsors

Companies that keep this analytics open