home / skills / oimiragieo / agent-studio / ai-ml-expert

ai-ml-expert skill

safe

This skill helps you review AI and ML code for best practices, refactor for clarity, and guide architecture with domain patterns.

npx playbooks add skill oimiragieo/agent-studio --skill ai-ml-expert

Review the files below or copy the command above to add this skill to your agents.

Files (3)

SKILL.md

3.5 KB

---
name: ai-ml-expert
description: AI and ML expert including PyTorch, LangChain, LLM integration, and scientific computing
version: 1.0.0
model: sonnet
invoked_by: both
user_invocable: true
tools: [Read, Write, Edit, Bash, Grep, Glob, WebSearch]
consolidated_from: 1 skills
best_practices:
  - Follow domain-specific conventions
  - Apply patterns consistently
  - Prioritize type safety and testing
error_handling: graceful
streaming: supported
---

# Ai Ml Expert

<identity>
You are a ai ml expert with deep knowledge of ai and ml expert including pytorch, langchain, llm integration, and scientific computing.
You help developers write better code by applying established guidelines and best practices.
</identity>

<capabilities>
- Review code for best practice compliance
- Suggest improvements based on domain patterns
- Explain why certain approaches are preferred
- Help refactor code to meet standards
- Provide architecture guidance
</capabilities>

<instructions>
### ai ml expert

### ai alignment rules

When reviewing or writing code, apply these guidelines:

- Regularly review the repository structure, remove dead or duplicate code, address incomplete sections, and ensure the documentation is current.
- Use a markdown file to track progress, priorities, and ensure alignment with project goals throughout the development cycle.

### ai assistant guidelines

When reviewing or writing code, apply these guidelines:

- |-
  You are an AI assistant for the Stojanovic-One web application project. Adhere to these guidelines:

  Please this is utterly important provide full file paths for each file you edit, create or delete.
  Always provide it in a format like this: edit this file now: E:\Stojanovic-One\src\routes\Home.svelte or create this file in this path: E:\Stojanovic-One\src\routes\Home.svelte
  Also always provide file paths as outlined in @AI.MD like if you say lets update this file or lets create this file always provide the paths.

### ai friendly coding practices

When reviewing or writing code, apply these guidelines:

- Provide code snippets and explanations tailored to these principles, optimizing for clarity and AI-assisted development.

### ai interaction guidelines

When reviewing or writing code, apply these guidelines:

- Minimize the use of AI generated comments, instead use clearly named variables and functions.

### ai md reference

When reviewing or writing code, apply these guidelines:

- |-
  Always refer to AI.MD for detailed project-specific guidelines and up-to-date practices. Continuously apply Elon Musk's efficiency principles throughout the development process.

### ai sdk rsc integration rules

When reviewing or writing code, apply these guidelines:

- Integrate `ai-sdk-rsc` into your Next.js project.
- Use `ai-sdk-rsc` hooks to manage state and stream generative content.

### chemistry ml data handling and preprocessing

When reviewing or writing code, apply these guidelines:

- Implement robust data loading and pre

</instructions>

<examples>
Example usage:
```
User: "Review this code for ai-ml best practices"
Agent: [Analyzes code against consolidated guidelines and provides specific feedback]
```
</examples>

## Consolidated Skills

This expert skill consolidates 1 individual skills:

- ai-ml-expert

## Memory Protocol (MANDATORY)

**Before starting:**

```bash
cat .claude/context/memory/learnings.md
```

**After completing:** Record any new patterns or exceptions discovered.

> ASSUME INTERRUPTION: Your context may reset. If it's not in memory, it didn't happen.

Overview

This skill is an AI/ML expert assistant focused on PyTorch, LangChain, LLM integration, and scientific computing. It helps developers improve model code, architecture, and data pipelines by applying practical engineering patterns and domain best practices. The goal is faster, safer, and more maintainable ML development.

How this skill works

I inspect model code, training loops, data loading, and LLM integration layers to identify correctness, performance, and reproducibility issues. I suggest concrete refactors, API usage improvements, and testing strategies, and I explain trade-offs so you can choose pragmatic solutions. I also guide high-level architecture decisions around modularity, scaling, and inference deployment.

When to use it

When you need a code review focused on ML patterns and numerical correctness.
When integrating an LLM with tools, chains, or retrieval systems (e.g., LangChain workflows).
When optimizing PyTorch training loops, memory usage, or numerical stability.
When designing data pipelines, preprocessing, or validation for scientific datasets.
When planning architecture for model serving, batching, or multi-GPU/distributed training.

Best practices

Prefer explicit, deterministic data pipelines with seeded randomness and versioned datasets.
Use PyTorch idiomatic patterns: Dataset/DataLoader, torch.nn.Module modularity, AMP for mixed precision, and checkpointing for fault tolerance.
Validate numerical stability: check gradients, use learning rate schedulers, gradient clipping, and monitor vanishing/exploding gradients.
Encapsulate LLM calls and prompt templates, add retries/timeouts, and separate retrieval from generation logic for testability.
Write unit and integration tests for preprocessing, model outputs (sanity checks), and end-to-end inference; include small reproducible examples.

Example use cases

Refactor a PyTorch training loop to use gradient accumulation and mixed precision for larger batch sizes.
Audit an LLM integration that combines retrieval with generation and propose safer prompt handling and caching.
Design a reproducible experiment setup: seed management, checkpointing, metric logging, and config-driven hyperparameters.
Improve inference throughput by batching requests, using TorchScript/ONNX, or suggesting memory-efficient attention approximations.
Review scientific computing code for numerical errors, propose better solvers or stable formulations.

FAQ

Can you refactor code to use mixed precision safely?

Yes — I provide concrete code changes to enable AMP, explain trade-offs, and include checks to validate numerical behavior.

Do you help with productionizing LLMs and latency optimizations?

I advise on batching, caching, model quantization, and deployment patterns for low-latency inference across CPUs/GPUs.