AI Automation & Agent Engineering

Write a system prompt that defines an agent's role, capabilities, constraints, and output format.

Apply few-shot prompting to teach an agent task-specific patterns from examples.

Use chain-of-thought and step-back prompting to improve reasoning on complex tasks.

Design and implement prompt templates that dynamically insert variables and instructions into a prompt.

Decompose a complex task into a sequence of smaller prompts (prompt chaining).

Identify prompt injection vulnerabilities and apply mitigation techniques (delimiters, XML tagging, input sanitization) to secure templates.

Identify common LLM failure modes in agent responses: hallucinations, format drift, refusal, and instruction loss.

Apply prompt engineering techniques to mitigate common LLM failure modes in agent responses.

Compare the API request and response structures for a simple tool call across OpenAI, Anthropic, and Gemini.

Define a tool with a JSON Schema parameter definition and connect it to a real function in Node.js.

Implement a tool-calling loop that lets the model invoke multiple tools across turns until a final answer.

Handle tool errors, retries, and timeouts gracefully inside the tool-calling loop.

Wrap a third-party REST API as an agent-callable tool using fetch in Node.js.

Wrap file system read/write operations as agent-callable tools with safe path handling.

Wrap a SQL database client as an agent-callable tool to perform queries.

Use parallel tool calls for independent operations and decide when to use tool calling versus structured output.

Distinguish between a workflow, a router, and an autonomous agent, and choose the right pattern for a given problem.

Design a system prompt and response parser for a ReAct-style thought/action cycle.

Implement the core ReAct execution loop in TypeScript that calls a tool based on a parsed action and feeds the result back to the model.

Implement a Plan-and-Execute agent that first produces a multi-step plan, then executes each step with tools.

Implement a single reflection step where an agent critiques and revises its own output before returning a final answer.

Use a router/dispatcher agent to delegate tasks to specialized sub-agents or workflows.

Compare the trade-offs of single-agent vs. multi-agent designs for a given problem.

Set termination conditions, max-step limits, and budget caps to prevent runaway agents.

Set up a TypeScript project with the Vercel AI SDK and call multiple LLM providers through its unified interface.

Define a tool compatible with the Vercel AI SDK and provide it to the `generateText` function.

Implement agent logic that processes tool-call requests, executes the function, and returns results to the model.

Stream agent responses and tool-call events to a Next.js frontend chat UI using the Vercel AI SDK.

Build a comparable agent with LangChain.js to evaluate framework ergonomics.

Compose agent components using LangChain Expression Language (LCEL) chains.

Integrate a pre-built tool from the LangChain.js community library (e.g., a web search tool).

Implement robust error handling and retry logic for tool calls within a LangChain.js agent.

Generate text embeddings in Node.js and demonstrate semantic similarity using cosine distance.

Chunk documents using fixed-size, recursive, and semantic splitting strategies.

Generate and store document chunk embeddings in a vector database (e.g., pgvector, Pinecone, or Qdrant).

Implement a retrieval function that embeds a user query and fetches the most relevant document chunks.

Construct a RAG prompt that combines retrieved context with the user query to generate a cited answer.

Improve retrieval quality using a hybrid search strategy (e.g., BM25 + vectors).

Implement a reranking step to refine the order of retrieved documents before generation.

Apply metadata filtering and per-user access control to secure a multi-tenant RAG pipeline.

Distinguish between short-term (context window) and long-term (external) memory strategies for agents.

Implement short-term conversational memory using an in-memory message history array.

Implement summarization-based memory to condense long conversations and manage context window limits.

Set up a local Postgres database using Docker and define a schema for persisting conversation history.

Persist and retrieve agent conversations from Postgres, keyed by user or session ID.

Implement long-term semantic memory that retrieves relevant past interactions using vector embeddings.

Implement a state-loading mechanism that allows a long-running agent to resume its operation after a server restart.

Implement a scheduled background agent that runs on a cron trigger (e.g., for proactive tasks).

Integrate OpenAI, Anthropic, or Gemini nodes into existing n8n and Make.com workflows.

Use an LLM node to classify, extract, and route incoming data from emails, forms, or tickets.

Design hybrid pipelines that combine deterministic automation steps with LLM reasoning steps.

Call a custom-built agent (hosted as an API) from n8n as part of a larger automation.

Trigger n8n workflows as tools from a JS agent using webhooks.

Add human-in-the-loop approval steps to AI-augmented workflows in n8n or Make.com.

Compare when to use a no-code workflow, an AI-augmented workflow, or a full agent for a business problem.

Build a simple business process automation that uses both n8n and a custom agent.

Set up a Python project for AI development using Poetry and demonstrate basic syntax for functions and data structures.

Model an agent system as a stateful graph of nodes and edges in LangGraph.

Implement conditional edges in LangGraph to route tasks based on agent state or tool output.

Implement cycles in a LangGraph workflow to enable iterative processes such as reflection or retries.

Build a multi-agent crew with CrewAI using role, goal, and backstory specifications.

Coordinate agents with sequential and hierarchical processes in CrewAI.

Add persistent state and checkpointing for long-running multi-agent systems.

Wrap a Python multi-agent system in a FastAPI HTTP API to be consumed by a JS application.

Define an evaluation dataset schema (input, expected output, criteria) for a specific agent task.

Build a small-scale evaluation dataset in JSONL format for automated testing.

Design a scoring rubric and prompt template for an LLM-as-a-judge evaluator.

Automate the evaluation of an agent's performance against a dataset using an LLM-as-a-judge script.

Instrument an agent with OpenTelemetry-compatible tracing (e.g., LangSmith, Langfuse) to analyze its execution flow.

Implement input guardrails to mitigate prompt injection and jailbreak attempts.

Implement output guardrails for schema validation, PII redaction, and toxicity filtering.

Configure cost, rate-limit, and step-limit controls to prevent runaway agent execution and spend.

Package a Node.js agent as a serverless function on Vercel or Cloudflare Workers.

Containerize a Python agent API with a Dockerfile and deploy it to a service like Render or Fly.io.

Manage secrets and environment variables locally with .env files and in production with platform secret stores.

Add authentication to an agent API using API keys or JWTs.

Implement per-user rate limiting on an agent API to prevent abuse.

Implement usage metering that tracks token consumption and tool calls on a per-user basis.

Implement caching for LLM and embedding calls to reduce cost and latency.

Use a background job queue (e.g., Inngest, Trigger.dev, or BullMQ) to manage long-running agent tasks.

Build a customer support agent that integrates knowledge-base RAG, ticket-system tools, and a human-handoff trigger.

Build a sales/lead-generation agent that researches leads, drafts personalized outreach, and updates a CRM via API tools.

Build a content/marketing agent crew that researches, drafts, edits, and schedules posts using multi-agent coordination.

Build an internal RAG assistant integrated with Slack that responds to user messages with cited answers.

Scope an AI automation project for a client, producing a proposal with deliverables, success metrics, and pricing.

Present an AI agent demo and its return-on-investment (ROI) case to a non-technical stakeholder.

Create a hand-off package for a client, including documentation, monitoring access, and a maintenance plan.

Conduct a mock client discovery call to practice identifying agent-based automation opportunities.