Daniel Avila

Use Perplexity to find web resources, recent information, or clear explanations drawn from the web. The skill chooses between search results and conversational answers, while directing specialized documentation and workspace questions to other tools.

• Finding recent information on a topic
• Discovering tutorials and blog posts
• Getting web-based explanations of concepts

Design and refine prompts for LLM applications by organizing roles, context, instructions, constraints, and output formats. Develop representative examples, manage the information supplied to the model, and evaluate changes to improve how consistently responses match expectations.

• Structuring a system prompt for an LLM application
• Specifying response formats and constraints
• Creating examples that include edge cases

Guides large language model reinforcement learning with miles, covering environment setup, low-precision training, consistency between training and inference, and speculative decoding, where a smaller model proposes tokens for a larger model to verify.

• Configure reinforcement learning for large MoE models
• Investigate instability in FP8 training
• Set up speculative decoding for faster rollout generation

Build search and recommendation features with Pinecone, a managed database for numerical representations of content. Covers data loading, combined meaning and keyword search, filtering by attributes, and separating data by user.

• Build document retrieval for AI answers
• Combine meaning and keyword search
• Separate search data by user

Explore training workflows that reduce harmful model responses using a written set of principles. The skill covers self-critique, revised training examples, and RLAIF, reinforcement learning from AI feedback, with implementation examples and hardware guidance.

• Designing principles for model safety training
• Creating training examples through self-critique and revision
• Planning reinforcement learning with AI-rated responses

Compress LLM weights using HQQ quantization, which stores weights with fewer bits without calibration datasets. Follow workflows for precision settings, model saving, inference integration, and LoRA fine-tuning of quantized models.

• Compressing LLMs without calibration datasets
• Serving quantized models with vLLM or HuggingFace Transformers
• Comparing bit widths and inference backends

Guide reinforcement learning, training models through rewards, with slime. Prepare data, configure Megatron-LM training and SGLang response generation, and set up asynchronous runs or custom multi-turn workflows for supported language models.

• Preparing reward-based training for GLM or Qwen models
• Overlapping response generation and training
• Training agents that use tools across multiple turns

Train language models with SimPO using pairs of preferred and rejected answers. Configure preference training without a separate reference model, adapt settings for base or instruction models, and address unstable training, memory limits, or lost capabilities.

• Training a base model with preferred and rejected answers
• Further tuning an instruction model with preference data
• Adjusting training settings for math and code tasks

Provides prompt templates for coding, writing, analysis, and creative work. Helps define the AI's role, specify the desired output, add examples and constraints, and refine requests using a practical checklist.

• Draft a prompt for code review
• Create requests for clear technical documentation
• Prepare prompts for feature and naming ideas

Coordinates specialist agents in Claude Code to work from product requirements through design, implementation, testing, deployment, and operations. Includes task queues, saved progress, parallel reviews, and recovery workflows for managing extended development work.

• Turning product requirements into development tasks
• Coordinating implementation, testing, and reviews
• Resuming extended work from saved progress

Build AI agents with LangGraph by connecting processing steps into a graph. Define shared state, conditional paths, tool calls, saved checkpoints, and human review points to create workflows that retain information as they run.

• Building an agent that calls tools in a loop
• Sharing accumulated findings between multiple agents
• Routing requests to different processing paths

Evaluate LLM application quality using automated scores, human reviews, and another language model as a judge. Compare models or prompts, establish baseline results, and detect quality drops through repeatable tests and statistical comparisons.

• Comparing models and prompts
• Checking quality before deployment
• Evaluating search quality in RAG applications

Use Phoenix to record execution traces, detailed records of an AI application's operations, and investigate problems. Evaluate answers on datasets, compare prompts and models, and set up monitoring through a self-hosted server.

• Investigate AI application problems using execution traces
• Evaluate answer quality across a test dataset
• Compare prompts and models through experiments

Build image captioning, visual question answering, and text-based image search with BLIP-2. The skill explains model selection, batch processing, and memory-saving settings, with Python examples for connecting image understanding to language models.

• Generating captions for multiple images
• Building a question-answering system for images
• Searching an image collection with text

Use LangSmith to record LLM application inputs, outputs, and timing, investigate failures, evaluate answers against test datasets, and monitor production usage. It also guides automated quality checks and analysis of token usage and costs.

• Investigating failures in LLM applications
• Evaluating answers against test datasets
• Monitoring production latency and costs

Design LLM applications using patterns for answers grounded in documents, agents that use tools, and prompt testing. Implementation examples also cover monitoring response quality, latency, costs, and failures during operation.

• Building an assistant that answers from internal documents
• Choosing an architecture for an agent that uses tools
• Comparing and versioning prompts

Turn audio and video into text with Whisper, including Japanese and other supported languages. This skill covers transcription, English translation, timestamped subtitles, model selection, and batch processing, with guidance on hardware needs and recognition limitations.

• Transcribing recorded meetings
• Creating subtitles for videos
• Translating multilingual recordings into English text

Use MLflow to record machine learning experiments, compare results, and manage model versions. The skill covers logging training settings, metrics, and files, organizing a model registry, and preparing models for local or cloud deployment.

• Comparing training settings and model performance
• Recording experiments for later reproduction
• Managing model versions and release stages

Investigate how transformer language models produce predictions with TransformerLens. This skill guides inspection of intermediate values and attention patterns, plus experiments that replace internal values to test their effects and identify components involved in model behavior.

• Inspecting attention patterns and intermediate values
• Testing output changes by replacing internal activations
• Analyzing attention head contributions to predictions

Use W&B to record machine learning experiments, visualize training, and compare results. The skill also covers automated searches for training settings and version tracking for datasets and models, helping teams share experiments and trace their inputs.

• Logging training metrics and viewing progress in real time
• Comparing experiments with different training settings
• Searching automatically for better training settings

Investigate why a PyTorch model behaves a certain way by changing its internal values with pyvene. The skill guides experiments that swap or remove activations, train interventions, compare outputs, and save or share intervention configurations.

• Locating model components that affect an output
• Swapping activations to test behavioral hypotheses
• Training interventions to investigate causal structure

Run language models locally with llama.cpp on CPUs, Apple Silicon, or AMD and Intel GPUs. The skill guides model setup, memory-saving GGUF format choices, interactive chat, and serving models through an OpenAI-compatible API.

• Running a language model on a CPU-only computer
• Setting up local chat on an Apple Silicon Mac
• Choosing model quantization to fit available memory

Evaluate language models with over 100 benchmark tests covering knowledge, math, coding, safety, and image understanding. Configure runs on Docker, Slurm computing clusters, or cloud infrastructure, compare models, and export results.

• Compare models using the same benchmark tests
• Run large evaluations on a Slurm cluster
• Evaluate safety and image understanding

Get guidance on adapting LLMs with Unsloth, including implementation, API usage, and debugging. Covers LoRA and QLoRA, methods for adjusting models with fewer trainable parameters, with a focus on training speed and memory use.

• Learning how to fine-tune models with Unsloth
• Exploring LoRA and QLoRA for efficient training
• Implementing features using Unsloth APIs