Most engineering decisions in AI start with recognition: knowing that a category of technique exists and roughly what it's for. You don't need to implement reinforcement learning from scratch to benefit from knowing it's the right shape for sequential decisions. This is a field guide, a compact catalog you can scan when a problem lands on your desk and you want to know what family of approaches fits.

Core AI approaches#

These are the broad families, each with the kind of problem it tends to suit:

• Reinforcement learning fits sequential decision-making, where actions now affect outcomes later. Think robotics, automated trading, and game AI.
• Natural language processing (NLP) handles text tasks: classification, summarization, question answering, and chatbots.
• Generative models produce new content, whether text, images, audio, or code, rather than just analyzing existing content.
• Graph-based learning works on data shaped like networks: social graphs, fraud rings, and recommendation systems where relationships carry the signal.
• Self-supervised learning learns from unlabeled data by generating its own training signal, which is how much of modern large-model pretraining works.
• Evolutionary algorithms suit optimization and scheduling problems, evolving solutions over generations toward a fitness goal.
• Neuro-symbolic AI combines explicit logic with neural networks, aiming to get the rigor of symbolic reasoning alongside the flexibility of learned models.
• Transfer and few-shot learning adapt a pretrained model to a new task with very little new data, standing on the shoulders of prior training.
• Multi-modal learning combines several input types at once, such as text plus images plus audio plus video, into a single model.

The value of this list isn't depth on any one item. It's that when you hit a problem about networks and relationships, "graph-based learning" surfaces, and when you hit a problem about acting over time, "reinforcement learning" surfaces. Recognition first, depth later.

Modern LLM engineering patterns#

The second catalog is more immediately practical for day-to-day work, because these are the patterns you actually assemble when building with large language models:

• Prompt engineering: shaping the input to steer the output. The cheapest, fastest lever, and often the first thing to reach for.
• Retrieval-augmented generation (RAG): retrieve relevant external information first, then have the model generate an answer grounded in what it retrieved. This is how you give a model access to facts it wasn't trained on without retraining anything.
• Fine-tuning and instruction tuning: adjusting a model's weights on your own examples to specialize its behavior or style.
• Few-shot and zero-shot prompting: providing a handful of examples in the prompt, or none at all, to guide the model's response format and approach.
• Agentic workflows: systems that plan a sequence of steps and act toward a goal, rather than producing a single response.
• Semantic search: matching on meaning rather than keywords, using embeddings so that "car" and "automobile" land near each other.
• Tool use and function calling: letting the model invoke external APIs and functions from a natural-language request, turning words into actions.
• Knowledge-graph integration: grounding a model in a structured graph of entities and relationships for more reliable, connected reasoning.
• Active learning: having the system identify which examples would be most valuable to label next, so human effort goes where it matters most.
• Human-in-the-loop (HITL): inserting deliberate human review and approval at key points, trading some autonomy for control and trust.
• Model distillation: training a smaller, cheaper model to mimic a larger one, capturing much of the capability at a fraction of the cost.

How to use this guide#

Don't try to memorize either list. Use them as a checklist when you're scoping. When someone describes a problem, run down the catalog and ask which family it resembles. Often the hardest part of an AI project is naming what kind of problem you actually have, and once it's named, the set of reasonable approaches narrows quickly.

A couple of patterns are worth reaching for early because they're cheap and high-leverage. Prompt engineering and RAG, in particular, solve a surprising share of real problems without any training, any model changes, or any new infrastructure. Start there, prove the value, and only climb the ladder toward fine-tuning, agents, or custom models when the simpler patterns genuinely run out of room. The catalog tells you what's possible; restraint tells you what to use.