Generative AI 101


Intelligent Agents — Module 2

A.Y. 2026/2027

Giovanni Ciatto



Compiled on: 2026-10-22 — printable version

back to ToC

GenAI: Generative Artificial Intelligence

AI algorithms capable of automatically generating content, e.g.:

  • text
  • images
  • audio and/or video
  • [source] code
  • …

(cf. Policy for the ethical and responsible use of Generative Artificial Intelligence in teaching and research activities)

GenAI through Foundation Models (FM)

  • Large neural networks that learn to process, “understand”, and produce [not necessarily] structured and unstructured data
  • trained on large amounts of data, and with large computational resources, to do a bit of everything
    • with the idea that they can later be specialized for specific tasks

Foundation models concept

Terminology: Foundation Models vs. Large Language Models

Venn diagram explaining how LLMs are a specific case of foundation models

Basic Operation of LLMs

Next token prediction: the LLM outputs a probability distribution over the next token, from which the next token is sampled
  • LLMs have learned to predict the next word (actually, token) in a text given the previous context
    • similar to the predictive keyboard on mobile phones, but much more complex and powerful
    • the next token is sampled from the predicted distribution: the temperature parameter controls how random the choice is
  • In other words, LLMs have learned how to use natural language
  • Foundation models can combine input/output text with other modalities (e.g. images, audio, video)
    • e.g. accepting text + image as input, and producing text + image as output, or any combination of these modalities
  • This makes them very good at dealing with unstructured data, either in input or output

About Tokens

  • LLMs do not process characters nor words, but tokens: chunks of text, as defined by the model’s tokenizer
    • you may think that token $\approx$ word, but this actually depends on the specific tokenization algorithm
Example of how a sentence is split into tokens
  • Tokens are the unit of measure for LLMs:
    • the context window is the maximum number of tokens a model can process in a single request (cf. context management)
    • the cost of using LLMs as services is commonly per token (cf. Open Router)

Language and Reasoning

  • Natural language helps people communicate

  • It can be used to express complex or abstract concepts

  • It can be used to reason about problems and solutions

    • however it admits imprecisions, due to ambiguity, variable interpretations, subjectivity, etc.

Natural language allows LLMs to use intuition in reasoning, like humans do
(thus making mistakes like humans do)

  • $\implies$ LLMs can be very confident in themselves, while saying incorrect, imprecise, or made-up things

    • a.k.a. hallucinations

  • better would be to combine LLMs with symbolic AI tools, to get the best of both worlds

Analogy with Dual-System theory

Dual-system theory concept

(cf. Thinking, Fast and Slow)

GenAI with an as-a-Service consumption model

'As-a-Service' consumption model for foundation models

GenAI with an as-a-Service consumption model

  • Cost models:

    • subscription-based: you pay a fixed monthly/annual fee to access the service
      • it often still includes usage limits
    • usage-based: you pay in proportion to the actual use of the service

  • Consumption is measured based on the computational effort required to serve the request:

    • processed tokens (for text)
    • number of requests (often also subject to rate limits, e.g. max requests per minute or day)
    • size of the processed data (for images, audio, video)
    • complexity of the specific model used to serve the request

  • Generation should be considered a stochastic process by construction

  • The quality of the service is subject to randomness and fluctuations due to:
    • service load
    • model choice, and its related updates
    • service limits possibly reached in the current time window
    • chance
  • But also: data leave your premises, costs scale, provider lock-in, GDPR and AI Act apply (cf. on-premise models, and the governance lecture)

GenAI learning cycle

GenAI learning cycle

GenAI learning cycle — Consequences (pt. 1)

  • Sampling bias: GenAI knows only what it has been trained on + the pious hope that it learns to generalize

  • Learning uses data taken from the Web + possible provider-owned company data

    • there is documented use of previous users’ interactions as feedback for subsequent training

  • Niche information may not be learned correctly (or at all)
  • It is essential to avoid sharing sensitive, confidential, or copyrighted information

GenAI learning cycle — Consequences (pt. 2)

  • Learning cycles are extremely expensive in terms of money and computational resources…

  • … performed periodically (weeks? months?) to improve the quality of the service

    • the as-a-Service consumption model gives the user transparent access to the updated service

  • Recent information may not have been learned yet
  • There is a risk of receiving outdated or incomplete answers from GenAI
  • GenAI gives the impression of learning during the conversation, but its weights are only updated offline
    • within a conversation, it just re-reads the whole history at each turn (cf. stateless APIs)
    • “memory” features of chat apps store notes about the user, and put them back into the context of later conversations

Some technological solutions let you opt out of training


ChatGPT settings: the toggle allowing OpenAI to use your conversations to train its models

(cf. regulation in the governance lecture)

Main technological solutions

Categorized by type of interface

Non-exhaustive list!

Conversational interface


  • Textual interaction that mimics a (chat) exchange
    • the user asks, the AI responds reactively
  • The interface allows entering a prompt
    • optionally including attachments (e.g. images, documents)
  • Responses are contextual
    • i.e., the conversation history affects future responses
  • The response contains text (often formatted)
    • optionally: images, URLs, code

Sometimes…

  • … before responding, the AI performs a Web search
  • important for obtaining up-to-date results

Auto-completion interface


  • The AI suggests a completion for the entered text
    • e.g., code, text, URLs
  • The user accepts (even partially) or ignores the suggestion
  • Used especially for programming code

Attention…

  • … subscription pricing model (see here)
  • … potential leaks of sensitive information
  • … non-negligible lock-in risk

Programmatic interface

OpenAI logo 
from openai import OpenAI

client = OpenAI()  # reads the API key from the OPENAI_API_KEY env variable

stream = client.chat.completions.create(
    model="gpt-5-mini",
    messages=[
        dict(role="user", content="European countries, one by line")
    ],
    stream=True,  # receive the response token by token
)
for chunk in stream:
    print(chunk.choices[0].delta.content or "", end="")

Output (excerpt, may vary):

Albania
Andorra
Austria
Belarus
Belgium
...

  • Programming language interacting with AI

    • e.g., Python, JavaScript

  • The interaction remains of the request-response type

    • the program sends a request, the AI responds
    • e.g. with the openai library: chat.completions.create(...) sends the messages of a chat (each with a role and a content) to a model
    • the response comes in chunks (stream=True), each carrying a piece (delta) of the generated text
    • details in the LLM-as-a-Service lecture

Enables

  • Parametric prompts, responses processed automatically

    • e.g. list of LOCALITIES in AREA, one by line
      • where LOCALITIES $\in$ {cities, regions, states}
      • and AREA $\in$ {Europe, Asia, Africa, America, Oceania}
      • results sorted alphabetically

  • Writing software that uses AI as a service

    • useful in both industry and research

Attention…

  • … usage-based pricing model (see here)
    • proportional to the number of processed tokens
    • prices vary by model

In-app interface


  • GenAI integrated into desktop or web applications

    • e.g., Microsoft Office (Word, Excel, Outlook)

  • support for an internal conversational interface

    • a conversation that is intrinsically contextualized

  • AI automates complex operations (within the app)

    • e.g., draft writing
    • e.g., generation of formulas, charts

Attention…

  • … subscription pricing model (see here)
  • … potential leaks of sensitive information
  • … non-negligible lock-in risk

Interface for editing audio/video content (e.g. music)

  • One-shot interaction to generate content

    • input: textual description of the content
    • output: content

  • The interface then allows

    • playback of the content
    • editing of the content
      • e.g., cutting parts, changing key

Example

Agentic interface

A Claude Code session in a terminal: the agent reads files and runs commands to answer the user's request

  • The user assigns a goal (a task), not just a question
  • The AI works in a loop: plan → act → observe → repeat
    • reads files, runs commands, edits code, searches the Web
  • It operates within a workspace
    • e.g. a repository, the file system, a shell (locally or in a cloud sandbox)
  • The user supervises
    • approves actions, interrupts, reviews the changes
  • Many front-ends: CLI, IDE, desktop, web, even messaging apps

Attention…

  • … side effects: it acts on your machine (e.g. deleted files, leaked secrets)
  • … prompt injection via the files and Web pages it reads
  • … heavy token consumption (subscription or usage-based pricing)
  • … review burden and risk of over-reliance
  • … non-negligible lock-in risk

Agentic interfaces (a.k.a. coding agents): the landscape

Vendor Front-ends Models License
Claude Code Anthropic CLI, IDE, desktop, web Claude proprietary
Codex OpenAI CLI, IDE, desktop, web GPT Apache-2.0 (CLI)
OpenClaw OpenClaw Foundation self-hosted, messaging apps (WhatsApp, Telegram, Slack, …) any (hosted or local) MIT
Cursor, Copilot (agent mode) Anysphere, GitHub IDE various proprietary

Common anatomy

  • An LLM + tools (shell, files, Web) + a loop $\Rightarrow$ an agent
    • the software wrapping the LLM (loop, tools, policies) is called the harness
  • Project-specific instructions in Markdown files (e.g. CLAUDE.md, AGENTS.md)
  • Extensible via MCP servers, skills, and hooks
  • Permission modes: from “ask before every action” to “fully autonomous”

These are themselves LLM-based agentic software: the kind of system this module teaches you to build

Customers buy automation, not agents

Why do people care about software in the first place? (cf. Introduction to Software Engineering)

  • Most people do not care about algorithms, software, or agents per se…

  • … they care about automating the solutions to their problems

    • algorithms, software, and now agents are just means to that end

  • Classic software automates problems which are repetitive and structured enough to be coded

  • GenAI widens the set of automatable problems

    • to problems which are linguistic, ill-defined, or about unstructured data
    • i.e. problems which are hard to code explicitly

Corollary

  • Autonomy is a cost (risks, testing, governance), not a goal
  • Aim for the least autonomy that gets the job done (cf. Building effective agents)

Three ways engineers exploit GenAI

Venn diagram: (1) coding assistants and co-pilots, (2) automating hard-to-code tasks, (3) agents in products; all intersections are possible
  1. As coding assistants and co-pilots
    • GenAI helps engineers build the software
  2. To automate activities which would otherwise be hard to code
    • GenAI is a step in a flow decided by the developers
  3. To create agents for software products
    • GenAI decides (part of) the flow, increasing the product’s autonomy
  • (1) is about the process (dev-time): the product may contain no AI at all
  • (2) and (3) are about the product (run-time)
    • they are ends of a spectrum: who controls the flow?
    • the developer’s code (workflow) vs. the LLM (agent)

Not mutually exclusive!

Each dimension on its own

  • (1) only: coding an ordinary Web application (no AI inside) with the help of Claude Code

    • cf. agentic interfaces
    • GenAI speeds up development, yet the final product is classic software

  • (2) only: a script which extracts structured data from recommendation letters

    • the steps are fixed in code (read letter $\rightarrow$ prompt LLM $\rightarrow$ validate output $\rightarrow$ store)
    • the LLM is one step among many: it does not decide what to do next

  • (3) only: a customer-support chatbot which decides which tools to call (e.g. look up orders, open tickets)

    • the LLM chooses the next action, based on the conversation
    • the product gains autonomy, and so does its risk profile

How the dimensions combine

Combination Example
(1) + (2) the letter-extraction script, written with a coding assistant
(2) + (3) an agent whose tools are themselves LLM-based workflows (e.g. the tender example)
(1) + (3) an agentic product built with a coding agent
(1) + (2) + (3) an assistant for a PhD admission committee (our running example): workflows to extract data from candidates’ documents, an agent to answer the committee’s questions, all coded with a coding agent

Twist

  • One team’s (1) is another team’s (3)
    • Claude Code is a tool for its users (1)…
    • … and an agentic product for Anthropic (3)

From language to action

  • An LLM produces text, not action

    • action requires software which maps text onto operations
    • e.g. Book the train to Lisbon is just text…
    • … until software maps it onto search, booking, payment, and confirmation steps

  • Are LLMs agents? Not really, not fully, not by themselves

    • they do not perceive nor act on environments directly
    • they do not persistently manage goals and state

  • In both (2) and (3), the “agent” is mostly the surrounding software

    • agent $\approx$ controller + LLM + tools + memory + policies

Intelligence vs. autonomy vs. agency are separable dimensions (cf. Floridi, 2025)

  • How well does it solve problems? (intelligence)
  • What can it do, i.e. what state does it actually change? (agency)
  • Who controls when and why it does it? (autonomy)

Language is a weak substrate for agency

  • Natural language is expressive and flexible…
    • useful for vague goals, exceptions, preferences, and explanations
  • … but also ambiguous and underspecified
    • fluent text may be plausible but false
    • confident text may be non-executable
    • e.g. get approval, then submit hides who approves, how approval is checked, and what submission changes

Hence: LLMs propose, software verifies

  • Treat LLM outputs as candidate artefacts (plans, classifications, explanations)…
  • … to be checked by external components: validators, tests, policy checkers, humans

What can GenAI do inside software? (dimensions 2–3)

Combine prompts, tools, vector stores, and agents to constrain and govern the behavior of pre-trained (foundation) models, in order to:

  • generate contents (text, images, code, etc.) for a specific purpose
    • e.g. bring unstructured data into a particular format
    • e.g. produce summaries, reports, highlights
  • interpret unstructured data and grasp information from it
    • e.g. extract entities, relations, sentiments
    • e.g. answer questions about a document
  • automate data-processing tasks which are hard to code explicitly
    • e.g. the task is ill-defined (write an evaluation paragraph for each student's work)
    • e.g. the task requires mining information from unstructured data (find the parties involved in this contract)
    • e.g. the task is complex yet too narrow to allow for general purpose coding (plan a vacation itinerary based on user preferences)
  • interact with users via natural language
    • e.g. chatbots, virtual assistants

Let’s explain the nomenclature

  • Foundation models (FM, always pre-trained): large neural-networks trained on massive datasets to learn general skills (e.g. ‘understanding’ and generating text, images, code), most commonly accessed as-a-Service via API, as provided by third-party companies

    • e.g. GPT (OpenAI), Claude (Anthropic), Gemini (Google), Llama (Meta), Mistral, Qwen (Alibaba), etc.
    • some are proprietary (usable only via the provider’s API), others are open-weight (downloadable and runnable locally, cf. on-premise deployment and open models)

  • Prompts: carefully crafted textual inputs that guide some FM to produce desired outputs

    • prompt templates are prompts with named placeholders to be filled with specific data at runtime
      • e.g. Write a summary of the following article: {article_text}

  • Tools: external software components (e.g. WebAPIs, databases, search engines) that FMs can ask to invoke (the invocation is performed by the surrounding software), to perform specific tasks or retrieve information

    • e.g. a calculator API, a weather API, a database query interface

  • Vector stores: specialized databases that store and retrieve high-dimensional vectors (embeddings) for the sake of information retrieval via similarity search

    • e.g. to support retrieval-augmented generation (RAG)

  • Agents: software systems that orchestrate the interaction between FMs and tools, enabling dynamic decision-making and task execution based on the context and user input

    • e.g. a chatbot that uses a FM for conversation and invokes a weather API when asked about the weather
    • e.g. an assistant that uses a FM to understand user requests and a database to fetch relevant information

What does an AI-powered application include? (pt. 1)

(i.e. a product exploiting GenAI as per dimensions (2) and (3))

  1. FM are commonly not produced in-house, but rather accessed via APIs… yet the choice of what model(s) to use is crucial

  2. A set of prompt templates (text files, or code snippets) that are known to work well for the tasks at hand (cf. prompting)

    • commonly assessed via semi-automatic evaluations on a validation set of inputs

  3. A set of tools that FMs can ask the application to invoke

    • these may be plain functions in the application’s code…
    • … or software modules exposing tools via MCP (MCP servers), somewhat similar to ordinary Web services

  4. A set of agents, implementing the logic to orchestrate the interaction between FMs and tools

    • these are software modules, commonly implemented via libraries such as LangChain or LlamaIndex

What does an AI-powered application include? (pt. 2)

  1. A set of vector stores (if needed), populated with relevant data, and accessible by the agents

    • these are software modules, somewhat similar to ordinary DBMS, offering CRUD operations on data chunks indexed by their embeddings

  2. Evaluations (deterministic scorers + LLM-as-a-Judge) to assess the quality of the outputs produced by the system, and to guide the improvement of prompts, tools, and agents

    • e.g. by comparing the output to a reference answer, and by assigning a score based on some criterion

  3. A set of workflows (if needed): code-controlled flows (state machines) whose steps call FMs, for procedures that must be reliable

  4. A set of skills (if needed): packaged instructions and scripts that agents load on demand

  5. Governance decisions: where models run (cloud vs. on-premise), at which cost, and under which regulations (e.g. the AI Act)

Roadmap of this module

Component Lecture
FMs, as-a-Service or on-premise; client libraries LLM-as-a-Service (+ free access)
Prompts, prompt templates, structured outputs Prompt engineering
Evaluations Validating generative software
Tools, MCP servers, agents Tools and agents
Vector stores Retrieval-Augmented Generation
Skills Agentic skills
Workflows, multi-agent systems Workflows
Model selection, deployment, regulation AI governance

Concept: Prompt Patterns

Technique Pattern template Description
Role playing You are an expert in {field} known for {key adjective}. Help me {task}. telling the AI to act as a famous expert or celebrity
Style unbundling Describe the key elements of {expert}'s style/skill in bullet points.
Do {task} in the following style: {style}.		 describe what you like about a style, rather than copying it directly
Emotion prompting Help me {task}. Please make sure {attribute}. This task is very important for my career. use emotional pressure and persuasion with the AI
Few-shot learning Here are some examples of {task}. Generate a {task} for {new context}. add examples of the completed task to the prompt
Synthetic bootstrap Generate ten examples of {examples} for {context}. Here are the inputs: {inputs}.
Generate {task} using {examples}.		 use AI to generate good examples of the completed task

(source: Lenny’s Newsletter)

  • {placeholders} are filled with actual data at runtime $\rightarrow$ prompt templates (cf. prompting)

Concept: Structured Outputs

  • Constrain the FM to answer with data (e.g. JSON) matching a given schema, rather than free text
    • the output can be parsed and validated by code, then stored or passed to other components
    • e.g. extracting name, nationality, and expiry date from a passport’s picture
  • (more on this in the prompting lecture)

Concept: Agents Calling External Tools

Sequence diagram: an agent discovers tools via MCP, the LLM requests a tool call, the agent invokes it via MCP, and the result is fed back to the LLM

Concept: Model Context Protocol (MCP)

Model Context Protocol (MCP) concept
  • MCP $\approx$ standard protocol for LLM-based applications to discover and call external tools (cf. specification)
  • Allows for decoupling between the agent’s logic and the implementation of the tools, thus enabling modularity and interoperability
  • Each MCP server exposes its own tools (names, descriptions, input schemas), plus possibly resources (data) and prompts (templates)
  • The host application (e.g. Claude Code, or your agent) runs one MCP client per server it connects to
    • optionally, a gateway may aggregate several servers behind a single endpoint

Concept: Retrieval-Augmented Generation (RAG)

RAG: indexing pipeline (chunking, embedding, vector store) and retrieval-and-generation pipeline (embedding the question, retrieving chunks, enriched prompt, LLM answer)

Concept: LLM-as-a-Judge

LLM-as-a-Judge concept
  • Exploiting an LLM to evaluate the quality of some other LLM’s output…
  • … based on some informal criterion (e.g. relevance, accuracy, completeness, etc.)
  • … by comparing the output to some reference (e.g. a human-written checklist)

(more on this in the validating lecture)

Concept: Agentic Skills

  • Folders of instructions (Markdown) and scripts, which an agent loads on demand, when relevant to the task
    • reusable procedures, written by domain experts in natural language
    • only names and descriptions stay in the context, until needed
  • (more on this in the skills lecture)

Concept: Workflows

  • The code decides the flow (a state machine, a graph of steps), and FMs fill in the steps
    • as opposed to agents, where the FM decides what to do next
    • predictable, testable, auditable; less flexible
    • e.g. extract $\rightarrow$ validate $\rightarrow$ score $\rightarrow$ report
  • (more on this in the workflows lecture)

The GenAI project lifecycle

(The lifecycle of engineering products as per dimensions (2) and (3). Similar to the ML lifecycle in the sense that the goal is to process data, but different in many details: e.g. training is optional, and commonly not performed in-house, as pre-trained FMs are exploited)

GenAI project lifecycle: scope, select, adapt and align model, application integration
  • there could be many iterations (e.g. for FM selection, and prompt tuning)
  • the whole lifecycle may be re-started upon data changes, or task changes, or new FM availability
  • the interplay between prompts, models, tasks, and data may need to be monitored and adjusted continuously
  • the data-flow between components (agents, FM, tools, vector stores) may need to be tracked for the sake of debugging and monitoring

Peculiar activities in a typical GenAI lifecycle

  1. Foundation model selection: choose the most suitable FM(s) based on task requirements, performance, cost, data protection, and availability

    • implies trying out prompts (even manually) on different models

  2. Prompt engineering: design, test, and refine prompt templates to elicit the desired responses

    • implies engineering variables, lengths, formats, contents, etc

  3. Evaluations: establish assertions and metrics to assess FM responses to prompts (attained by instantiating templates over actual data)

    • somewhat similar to unit tests in ordinary software
    • important when automatic, as they allow quick evaluations on prompt/model combinations

  4. Tracking the data-flow between components (agents, FM, tools, vector stores) to monitor costs, latency, and to debug unexpected behaviors

    • also useful for the sake of auditing and governance
    • commonly performed via logging and tracing tools, e.g. LangSmith, or MLflow

Example of GenAI lifecycle (pt. 1)

Support public officers in managing tenders through a GenAI assistant that understands and compares procurement decisions transparently.

Scope

  1. Problem Framing:

    • Content Generation: draft and justify comparisons among suppliers’ offers vs. technical specs
    • Interpretation: understand regulatory documents and technical language
    • Automation: score offers against check-lists derived from the technical specs
    • Interaction: enable officers to query and validate results through natural language
    • i.e. a workflow (dimension 2) for scoring, plus an agent (dimension 3) for the officers’ questions

  2. Data Collection: past tenders’ technical specifications and acts; regulatory documents; previous evaluations (with the officers’ scores)

  3. Data Preparation:

    • devise useful data schema & extract relevant data from documents
    • anonymize sensitive info (personal data; supplier identities, to reduce bias)
    • segment documents and index by topic (law, SLA, price table, etc.)

Select

  1. Foundation Model Selection: multi-lingual? specialized in legal/technical text? cost constraints? support for tools? where does it run (data protection)?
    • try out candidate prompts on candidate models

Example of GenAI lifecycle (pt. 2)

Adapt and align

  1. Vector stores: embeddings for tender documents & specs, legal texts & guidelines, previous evaluations, templates

    • choose embedding model and chunking strategy, populate the store, engineer retrieval strategies

  2. Prompt Engineering: templates for check-list extraction, justification, and Q&A

    • role-based system prompts (You are a procurement evaluator…), placeholders for retrieved chunks, iterate on manual tests

  3. Evaluations: past tenders (with the officers’ scores) as validation set

    • exact checks on extracted check-lists and scores; LLM-as-a-judge on justifications (e.g. is every claim backed by a cited document?)
    • re-run at every change of prompts or models

Application integration

  1. Tools: regulation lookup API, tender database query API, report generation out of document templates

    • scores are computed by deterministic code out of the (validated) check-lists: the LLM proposes, software verifies

  2. Workflow + Agent:

    • workflow: extract check-lists $\rightarrow$ validate $\rightarrow$ score $\rightarrow$ generate comparison report
    • agent: answers officers’ questions, orchestrating RAG and tool invocations

  3. Tracking & Oversight:

    • log prompts, retrieved chunks, tool calls, and scores, for traceability and auditing
    • the system proposes, the officer decides (and signs off); comply with GDPR and the AI Act (cf. governance)

Check your understanding

  • Answer in your own words, motivating your conclusions and using examples where useful.

  • Questions asking whether something is possible or desirable require more than a yes/no answer.

  • Implementation questions can be answered with an explanation or pseudocode unless executable code is explicitly requested.

  • Labels identify the primary learning target:

    • notions (knowledge), reasoning (drawing conclusions), or know-how (applying knowledge).
    • theoretical questions are independent of particular technologies; practical questions concern their use.

  • Practical answers should identify the technology used, without requiring memorisation of product-specific details (model names, prices, API signatures, versions, limits).

Check your understanding (1/4)

Foundations

  1. [notions, theoretical] What is generative AI? How are foundation models, large language models, and multimodal models related?

  2. [notions, theoretical] How does an LLM generate text? What roles do tokens, context, and temperature play?

  3. [reasoning, theoretical] How does the training of a foundation model affect what it can and cannot do? Why might it perform poorly on recent or uncommon information?

Check your understanding (2/4)

Foundations

  1. [reasoning, theoretical] If a chatbot remembers what you told it, has it learned something? Discuss the possible meanings of “learning” in this case.

  2. [reasoning, theoretical] Why can an LLM produce a convincing but incorrect answer? Would making its output deterministic solve the problem?

  3. [reasoning, theoretical] What are the benefits and limitations of combining language-based reasoning with symbolic computation? How does this relate to the distinction between intuitive and deliberate thinking?

Check your understanding (3/4)

Generative AI and software

  1. [know-how, practical] What kinds of interfaces to generative AI systems are available? Choose examples of existing applications and explain what tasks you would use them for.

  2. [reasoning, practical] What is the difference between a language model and an application built around it? Using an application you know, discuss which capabilities require more than text generation.

  3. [reasoning, theoretical] How can generative AI be used in software engineering? Distinguish its use in developing a product from its use within the product.

Check your understanding (4/4)

Generative AI and software

  1. [know-how, theoretical] Give an example of a task for which generative AI is useful and another for which ordinary software is preferable. What makes the difference?

  2. [reasoning, theoretical] Can an AI-text detector establish whether a student wrote an assignment? What would make its result convincing or unconvincing evidence?

  3. [notions, theoretical] What activities does engineering a generative AI application involve? How does its lifecycle differ from that of ordinary software and of classic machine-learning projects?

Lecture is Over


Compiled on: 2026-10-22 — printable version

back to ToC