What You Can Build: The Foundation-Model Use-Case Map

Introduction

You know what an AI engineer is. Now: what can you actually build?

Because foundation models are general-purpose, the answer is dizzyingly broad — which is exactly why beginners freeze ("where do I even start?"). This lesson gives you a map of the possibility space and, more usefully, a lens for spotting opportunities wherever you look.

You'll learn:

The handful of primitives every use case is built from
The use-case map — the main categories, with concrete 2026 examples
A simple lens for spotting where AI fits
Why a use case isn't yet a product (and what closes the gap)
When you should not reach for an LLM

It's All a Few Primitives

The thousands of AI products out there look varied, but underneath they compose a small set of primitives — things a foundation model just does:

Generate text (write, draft, brainstorm)
Summarize (long → short)
Extract / transform (unstructured → structured; reformat)
Classify (bucket into categories)
Translate (between languages — or styles)
Converse (multi-turn dialogue)
Reason (multi-step problem-solving)
Write code (and explain, review, fix it)
Understand images/audio (multimodal)

That's the whole alphabet. Every use case below is just these primitives composed. The proof: the same model can power a chatbot, a code assistant, a document summarizer, and a search interface — simultaneously. Learn to combine primitives and you can build almost anything.

The Use-Case Map

Here are the major categories foundation models power today (the taxonomy from Chip Huyen's AI Engineering), each with concrete, shipping-in-2026 examples:

Coding — copilots, code review, test generation, large-scale migrations & refactors.
Writing & Content — drafting, marketing copy, rewriting/editing, translation.
Conversational Bots — customer support, in-app assistants, tutors.
Information Aggregation — summarizing docs & meetings, research, enterprise search, RAG Q&A over your own data.
Data Organization & Extraction — parsing contracts/invoices/résumés, turning messy text into clean structured data, tagging & classification ("document intelligence").
Workflow Automation — agents that take actions across tools: triage tickets, schedule, reconcile, run multi-step ops.
Image / Video / Audio — multimodal generation & understanding: design assets, OCR, voice assistants, transcription.
Education — personalized tutoring, explanations, practice problems, feedback (you're using one right now).

Most enterprise value in 2026 still clusters around text, code, conversation, and reasoning — the unglamorous categories (document intelligence, support, internal search, coding) often deliver the clearest ROI.

A use-case map. A central banner reads 'One foundation model can power…'. Below it, eight category cards arranged in a grid: Coding (copilots, code review, migrations), Writing & Content (drafting, marketing, translation), Conversational Bots (support, assistants, tutors), Information Aggregation (summaries, research, enterprise search, RAG Q&A), Data Extraction (contracts, invoices, structuring, tagging), Workflow Automation (agents that triage, schedule, run ops), Image / Video / Audio (generation, OCR, voice), and Education (tutoring, explanations, practice). A caption notes all are built by composing a few primitives.

A Lens for Spotting Opportunities

You don't need to memorize categories — you need a lens. Ask:

"Where do people do repetitive language or judgment work over text, code, or images?"

Anywhere humans read, write, summarize, classify, or decide over unstructured content is a candidate for AI. Then place the idea on two axes to gauge risk:

Augment vs. Automate — does AI assist a human (they stay in the loop) or replace the step entirely? Augmenting is lower-risk and where most wins start.
Internal vs. Customer-facing — internal tools tolerate more rough edges; customer-facing demands far higher reliability and guardrails.

Best first projects sit in the safe quadrant: internal + augmenting (e.g., a tool that drafts replies for support agents to review). High value, forgiving of mistakes, fast to ship.

What Companies Actually Pay For

The map shows what's possible; here's where the money and the jobs concentrate in 2026 — the highest-demand, clearest-ROI builds:

Support copilots — draft and triage customer replies (the single most common enterprise build).
Internal & enterprise search — RAG over company docs, wikis, and tickets.
Coding assistants — copilots, code review, and large migrations.
Document extraction — contracts, invoices, and forms → clean structured data.
Workflow automation — agents that take action across internal tools.

Here's the chain that makes this worth your time:

the skills in this course → these builds → the AI-engineer roles hiring for them → the strong compensation from lesson 1.

Learn to ship the builds on this list and you are directly employable. Every container ahead is teaching you exactly these — RAG (search, extraction), agents (automation, copilots), evals & LLMOps (making them production-grade).

One Model, Many Jobs

To feel "primitives composed," watch one model do three different jobs on the same input — changing nothing but the prompt:

from anthropic import Anthropic
client = Anthropic()

review = "The checkout was confusing and slow, but the product quality is excellent."

jobs = {
    "summarize": "Summarize this in 5 words or fewer:",
    "extract":   "Extract the complaints as a JSON array of short strings:",
    "classify":  "Sentiment? Reply with one word: POSITIVE, NEGATIVE, or MIXED.",
}

for name, instruction in jobs.items():
    r = client.messages.create(
        model="claude-sonnet-4-6", max_tokens=60,
        messages=[{"role": "user", "content": f"{instruction}\n\n{review}"}],
    )
    print(f"{name:10} -> {r.content[0].text.strip()}")

# summarize  -> Confusing checkout, excellent product
# extract    -> ["confusing checkout", "slow checkout"]
# classify   -> MIXED

Same model, same input, three products' worth of behavior — summarizer, data extractor, classifier — selected purely by the prompt. That flexibility is the raw material; your job is to compose and harden it into something real.

See It Live: One Model, Many Jobs

The code above runs three jobs; now run them yourself. Pick an input, then a job — the same model on the same text becomes a summarizer, a data extractor, a classifier, a translator, a support reply, or a triage router, changing only the prompt. Each result is tagged with the use-case category it maps to.

Interactive: One Model, Many Jobs. The user selects one of three inputs — a customer review, a support ticket, or a meeting note — and then selects a job to run on it: summarize, extract, classify, translate, draft a reply, triage, or draft an announcement. The same model returns a different product for each job, selected only by changing the prompt, and every output is tagged with the use-case category it maps to: summarizing maps to information aggregation, extracting to data extraction, classifying to classification, translating or drafting to writing and content, replying to conversational bots, and routing to workflow automation. A counter tracks how many jobs the user has run on the current input and how many distinct use cases that unlocks; after three or more jobs on one input, a reveal lands the lesson that the same model produced several products' worth of behavior selected only by the prompt, because every use case is a few primitives — generate, summarize, extract, classify, translate, converse, reason — composed, and one foundation model powers them all. The takeaway it makes concrete is that the model is the raw material and the AI engineer's job is to compose and harden those primitives into a real product.

You never changed the model — only the prompt. That flexibility is the raw material; the rest of this course teaches you to compose and harden these primitives into something correct, grounded, and safe enough to ship.

From Use Case to Product (the gap)

A use case is the idea; it is not yet a product. The demo that wows in five minutes still has to become something that's correct, grounded, fast, affordable, and safe for thousands of real, messy users. That gap — recall lesson 1's "the demo is easy; production is the craft" — is precisely the engineering this course teaches: context & RAG for grounding, evals for trustworthy quality, guardrails for safety, cost & latency work for scale, and UX for trust. The map shows you what to build; the rest of the course teaches you to actually ship it.

Reality Check — When NOT to Use an LLM

A foundation model is a powerful, probabilistic tool — not the answer to everything. Reach for something else when:

The task is deterministic and exact. Math, sorting, lookups, business rules — write code; it's correct, instant, and free.
Simple rules suffice. A regex or if-statement beats an LLM for trivial pattern-matching (cheaper, faster, predictable).
A classical ML model fits better. Huge-volume, narrow classification on tabular data can be cheaper and more accurate with traditional ML.
It's high-stakes with no guardrails or human review. Don't put an ungrounded LLM in charge of irreversible or safety-critical decisions.

The mark of a good AI engineer isn't using LLMs everywhere — it's knowing exactly where they're the right tool, and where they aren't.

🧪 Try It Yourself

Map your own idea. Think of one problem you'd love an AI feature for, then place it on the use-case map: is it extraction, classification, generation/chat, RAG (Q&A over your data), or an agent (multi-step + tools)?

That single classification already tells you most of the architecture you'll need — and which later section of this course to focus on. (Most real products are a combination, e.g. RAG + extraction.)

Key Takeaways

Every AI product composes a few primitives — generate, summarize, extract, classify, translate, converse, reason, code, perceive. One model does them all.
The use-case map spans coding, writing, bots, information aggregation, data extraction, workflow automation, multimodal, and education — with the clearest 2026 ROI in document intelligence, support, search, and coding.
Spot opportunities with one lens: repetitive language/judgment work over text/code/images. Start in the safe quadrant: internal + augmenting.
A use case is an idea; engineering turns it into a product (grounding, evals, guardrails, cost, UX).
Know when not to use an LLM — deterministic, rule-based, or high-stakes-without-guardrails tasks belong elsewhere.

Next: the AI engineering mindset — build-vs-buy, eval-first, and iterate — the habits that separate shippers from demo-makers.