DEV Community: Guillermo Alcántara

Mastering Prompting for AI Agents: Insights and Best Practices

Guillermo Alcántara — Sat, 09 Aug 2025 19:21:06 +0000

In the rapidly evolving landscape of artificial intelligence, particularly in the development of intelligent agents, prompt engineering has emerged as a crucial skill. In a recent presentation, AI experts Hannah and Jeremy from Anthropic delved into the nuances of crafting effective prompts for AI agents. This blog post distills their insights, providing clear guidelines and examples to help you leverage AI agents effectively.

Understanding AI Agents

At the core of this discussion is the concept of AI agents—systems that use tools to execute tasks continuously and autonomously. Unlike basic prompt interactions, AI agents integrate feedback from their environment, making decisions based on the information they gather. Here’s a simplified breakdown of what an agent encompasses:

Tasks with Autonomy: Agents receive a task and, using various tools, work independently to complete it—much like a human solving a multifaceted problem.
Environment & Tools: An agent operates within a defined environment equipped with the tools necessary for task completion. The message you convey through prompts essentially acts as the guiding instruction, determining what the agent should accomplish.

When to Use AI Agents

Not all tasks require the sophistication of agents. Here’s a quick checklist to determine if an agent is suitable for your scenario:

Task Complexity: Is the task intricate enough that a step-by-step human approach isn't clear? If the process is straightforward, it might be better to stick with simpler workflows.
Valuable Outcomes: Is the task poised to provide significant value—like revenue generation or improving user experience? High-leverage tasks are candidates for agents.
Feasibility: Can you define and provide the necessary tools or information for the agent to execute the task? Without clarity in tool access, it may be better to limit the task scope.
Error Impact: What are the repercussions of errors? If a mistake is costly or hard to correct, it may be prudent to keep a human in the loop.

Examples of Effective Use Cases

Coding Projects: When turning a design document into a pull request (PR), agents can navigate the complexity of coding tasks autonomously, resulting in significant time savings for highly-skilled engineers.
Search Processes: In scenarios where searches can be rectified through citations or double-checking results, deploying an agent could streamline the task. For instance, when searching for information about various startups, an agent can autonomously adjust its searches based on gathered data.
Data Analysis: When delineating insights from varied data sets with unpredictable formats, agents can navigate the complexities without needing a perfectly defined pathway.

Best Practices for Prompting Agents

Jeremy offered several guidelines on how to construct effective prompts for agents, emphasizing a cognitive approach to tool selection:

Think Like Your Agent: Develop a mental model of the agent’s environment and tasks. Understand from an agent’s perspective what tools and responses are necessary for successful execution.
Define Reasonable Heuristics: Guiding agents with clear, practical heuristics helps shape their decision-making processes. This could pertain to resource allocation, such as setting tool call limits based on query complexity.
Tool Selection Is Vital: Specify which tools the agent should leverage for different tasks. For instance, if a company heavily relies on Slack for communication, the agent should prioritize this tool for relevant tasks.
Plan and Reflect: Encourage agents to plan their actions prior to execution. Notably, using interleaved thinking, agents can reflect on their search results before proceeding, allowing for smarter decision-making.
Beware of Unintended Side Effects: As agents function autonomously, changes in prompts may lead to unpredictable results. If an agent is directed to "keep searching," ensure to include contingencies for scenarios where desired outputs don’t exist.
Manage Context Windows: With models that handle extensive context windows, strategies like compaction—summarizing excessive context to maintain focus—can be beneficial.

Evaluating Agent Performance

Performance evaluation is crucial for understanding effectiveness:

Use Realistic Tasks: Ensure evaluation tasks reflect real-world scenarios relevant to the agent's functions.
Leverage LLMs for Judging: Using language models as judges can help in assessing outputs against established rubrics, allowing for a more nuanced evaluation of agent performance.
Check Final States: Confirm that your agent completes tasks correctly by checking if it reaches the desired end state, such as updating a database correctly.

Conclusion

Building effective prompts for AI agents is an iterative process that demands clarity, strategy, and thoughtful evaluation. By understanding when to deploy agents and refining your prompting techniques, you can unlock the full potential of AI-driven solutions. Whether in coding, data analysis, or information retrieval, these best practices will help you streamline workflows and achieve more valuable outcomes.

Feel free to explore these concepts further and adapt the insights shared here to meet your specific AI use cases and contexts.

Summary from Prompting for Agents - Anthropic
https://www.youtube.com/watch?v=XSZP9GhhuAc

Feature Engineering: A Practical Guide to Doing It Right

Guillermo Alcántara — Wed, 16 Apr 2025 03:06:04 +0000

Introduction

You’ve probably heard it a hundred times: feature engineering is the key to unlocking better model performance. But what does that actually mean? And more importantly—where do you start?

If you’re staring at a dataset and feeling unsure what to do with it, you’re not alone. Maybe it’s a mix of numbers, categories, and even some free-form text. Maybe you’ve already thrown it into a model and gotten “meh” results. And now you’re wondering: am I missing something obvious?

Here’s the thing—most people jump straight into feature engineering without really understanding their data. That’s like trying to decorate a house before it’s even built. To do this well, you need a framework. One that helps you identify the type of data you’re working with, choose the right techniques, and measure whether what you’re doing is actually making a difference.

This article breaks it all down for you. You’ll learn the core principles behind feature engineering, including:

The difference between structured and unstructured data—and why it matters
How to classify features into four key levels (and what you can actually do with them)
A clear breakdown of the five main types of feature engineering
How to evaluate your work beyond just model accuracy
And finally, a repeatable, step-by-step process to do it all with confidence

If you're ready to stop guessing and start engineering your features with purpose—this is your blueprint.

1. Structured vs. Unstructured Data

Before you apply any feature engineering techniques, you need to understand what kind of data you're working with.

Structured data lives in spreadsheets and databases—think rows and columns, like customer age, income, or product ratings. It's neat, easy to query, and easy for machine learning models to parse.
Unstructured data includes things like text, images, audio, or video. There’s no predefined format. It makes up roughly 80% of enterprise data, but it’s harder to work with.

Most machine learning models need structured input. So, if you’ve got unstructured data, your first task is to transform it—usually through feature extraction or feature learning.

Sometimes, datasets are a mix of both. For example, a customer service dataset might include structured fields like time of call, and unstructured fields like call transcripts. The goal is always the same: get it into a structured format your model can understand.

2. The Four Levels of Data

Understanding the type of each feature in your dataset is critical because it determines what you can (and can’t) do with it. Here are the four levels:

Nominal (Qualitative, No Order)

Examples: blood type, product category
Only meaningful operations: mode, counts
Common technique: convert to binary/dummy variables

Ordinal (Qualitative, Ordered)

Examples: satisfaction rating, education level
Has order, but gaps between values aren’t consistent
Strategy: assign integers (e.g. 1–5), but avoid maths on them unless it makes sense

Interval (Quantitative, No True Zero)

Examples: temperature in Celsius, dates
Differences are meaningful, ratios aren’t
OK to calculate: mean, standard deviation
Avoid: saying “twice as much” (e.g. 100°C ≠ 2× 50°C)

Ratio (Quantitative, True Zero)

Examples: age, income, weight
All arithmetic operations are valid, including ratios
You can use arithmetic, geometric, or harmonic means

Quick Tip:

Misclassifying interval vs. ratio isn’t the end of the world. But mixing up qualitative and quantitative types can break your model logic.

3. The Five Types of Feature Engineering

Once you understand your data and its levels, you can start applying the right techniques. Here’s a breakdown of the five main types of feature engineering:

1. Feature Improvement

Goal: clean and refine existing features
Techniques: fill missing values, scale numbers, normalise distributions
When to use: features are noisy, incomplete, or skewed

2. Feature Construction

Goal: create new features from existing ones
Example: combine "day" and "hour" into "daypart", or map text categories to sentiment scores
Requires: domain knowledge and logic
When to use: original features lack signal or need transformation

3. Feature Selection

Goal: keep only the most relevant features
Benefits: reduces overfitting, speeds up models, improves interpretability
Techniques: correlation filtering, mutual information, model-based selection
When to use: high dimensionality, multicollinearity, or slow training times

4. Feature Extraction

Goal: reduce dimensionality or summarise unstructured data
Techniques: PCA, SVD, Bag-of-Words for text
When to use: assumptions about structure are valid, or when simplifying data

5. Feature Learning

Goal: let deep models create features from raw data
Techniques: autoencoders, CNNs, GANs
Powerful, but: needs lots of data, features may be hard to interpret
Best for: images, audio, text—when manual engineering isn’t feasible

4. How to Evaluate Feature Engineering

Creating new features is one thing—knowing if they actually help is another. Here’s how to assess their impact:

Machine Learning Metrics

Compare model performance (accuracy, precision, recall) before and after applying techniques
Look for real gains, not just tiny improvements

Interpretability

Can you explain what a feature does?
Human-friendly features help with debugging, stakeholder trust, and regulatory compliance
Simpler models often win here (e.g. using decision trees instead of deep nets)

Fairness and Bias

Watch for features that encode bias (e.g. postcode might correlate with race or income)
Good feature engineering can help reveal and reduce these risks

Speed and Complexity

Fewer, more informative features usually train faster
High-dimensional data can slow things down and increase storage/memory needs

5. The Feature Engineering Process

Here’s a repeatable, 5-step process to follow:

Structure Your Data
- Convert unstructured data to structured using extraction or learning
Classify Feature Types
- Assign each feature a level: nominal, ordinal, interval, or ratio
Apply Engineering Techniques
- Choose from the five categories: improve, construct, select, extract, or learn—based on your feature types
Evaluate Impact
- Use model performance, interpretability, fairness, and speed as your criteria
Iterate
- Based on results, repeat or adjust your techniques

Final Thoughts

Feature engineering isn’t about using every technique under the sun—it’s about using the right ones, for the right data, at the right time. Start by understanding your data. Know its structure. Know its level. And use that knowledge to apply logical, targeted transformations.

When you follow this framework, you stop guessing and start building features that actually move the needle. That’s how you make your models smarter—not just bigger.

Implementing similarity search algotithms

Guillermo Alcántara — Wed, 16 Oct 2024 18:51:25 +0000

Get the data

import pandas as pd


descripciones = [
        'All users must reset passwords every 90 days.',
        'Passwords need to be reset by all users every 90 days.',
        'Admin access should be restricted.',
        'Passwords must change for users every 90 days.',
        'Passwords must change for users every 80 days.'
    ]

# Cargar el dataset
data = pd.DataFrame({
    'Rule_ID': range(1, len(descripciones) + 1),
    'Description': descripciones
})

Lexical similarity

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

!
# Vectorización de las descripciones con TF-IDF
vectorizer = TfidfVectorizer().fit_transform(data['Description'])

# Calcular la matriz de similitud de coseno
cosine_sim_matrix = cosine_similarity(vectorizer)

# Crear un diccionario para almacenar las relaciones sin duplicados
def find_related_rules(matrix, rule_ids, threshold=0.8):
    related_rules = {}
    seen_pairs = set()  # Para evitar duplicados de la forma (A, B) = (B, A)

    for i in range(len(matrix)):
        related = []
        for j in range(i + 1, len(matrix)):  # j comienza en i + 1 para evitar duplicados
            if matrix[i, j] >= threshold:
                pair = (rule_ids[i], rule_ids[j])
                if pair not in seen_pairs:
                    seen_pairs.add(pair)
                    related.append((rule_ids[j], round(matrix[i, j], 2)))
        if related:
            related_rules[rule_ids[i]] = related

    return related_rules

# Aplicar la función para encontrar reglas relacionadas
related_rules = find_related_rules(cosine_sim_matrix, data['Rule_ID'].tolist(), threshold=0.8)

# Mostrar las reglas relacionadas
print("Reglas relacionadas por similitud:")
for rule, relations in related_rules.items():
    print(f"Rule {rule} es similar a:")
    for related_rule, score in relations:
        print(f"  - Rule {related_rule} con similitud de {score}")

Semantical similarity

!pip install sentence-transformers
from sentence_transformers import SentenceTransformer, util


# Load the pre-trained model for generating embeddings
model = SentenceTransformer('all-MiniLM-L6-v2')

# Generate sentence embeddings for each rule description
embeddings = model.encode(data['Description'], convert_to_tensor=True)

# Compute the semantic similarity matrix
cosine_sim_matrix = util.cos_sim(embeddings, embeddings).cpu().numpy()

# Function to find related rules based on semantic similarity
def find_related_rules(matrix, rule_ids, threshold=0.8):
    related_rules = {}
    seen_pairs = set()  # To avoid duplicates of the form (A, B) = (B, A)

    for i in range(len(matrix)):
        related = []
        for j in range(i + 1, len(matrix)):  # Only consider upper triangular matrix
            if matrix[i, j] >= threshold:
                pair = (rule_ids[i], rule_ids[j])
                if pair not in seen_pairs:
                    seen_pairs.add(pair)
                    related.append((rule_ids[j], round(matrix[i, j], 2)))
        if related:
            related_rules[rule_ids[i]] = related

    return related_rules

# Apply the function to find related rules
related_rules = find_related_rules(cosine_sim_matrix, data['Rule_ID'].tolist(), threshold=0.8)

# Display the related rules
print("Reglas relacionadas por similitud semántica:")
for rule, relations in related_rules.items():
    print(f"Rule {rule} es similar a:")
    for related_rule, score in relations:
        print(f"  - Rule {related_rule} con similitud de {score}")