Prompt
A prompt is text or other input supplied to an AI model to provide instructions, context, or other information that guides its response or generated output.
Software Testing with Generative AI
A prompt is an input instruction or context supplied to a language model to guide its generated output.
- How it is used
- Uses targeted instructions to obtain useful assistance for testing, development, test planning, automation, and test-data creation.
- How deep it goes
- Defines prompts and develops construction tactics through worked examples, but stops short of guaranteeing reliable or self-validating outputs.
- Examples
- Demonstrates file-upload tests, contact-form risks, code-risk analysis, booking-list test cases, Java comments, unit checks, and JSON datasets.
- What you can do after
- Apply it via prompt-engineering tactics to request focused suggestions, structured outputs, test cases, risks, code, comments, or test data.
Read how Software Testing with Generative AI explains prompt →
Coding with AI
A prompt is natural-language input that instructs a generative artificial-intelligence system what response or result to produce.
- How it is used
- Uses prompts throughout software development to guide planning, code generation, review, debugging, and interface design.
- How deep it goes
- Explains prompt components and refinement through practical examples, including role prompts, debugging requests, and editor context.
- Examples
- Contrasts vague and specific SQLite connection comments and requests validation and tests for a Python discount function.
- What you can do after
- Apply prompts through ChatGPT and coding assistants, iteratively refining requests and validating generated suggestions.
AI for Everyday IT
A prompt is an instruction or input supplied to an AI system to elicit a specified response or output.
- How it is used
- Uses prompts to direct AI assistance across IT tasks, workplace communication, learning, and management.
- How deep it goes
- Defines prompts and works through specificity, iteration, examples, and system-role instructions without developing model internals.
- Examples
- Illustrates prompts with ESL grammar practice, email summaries, Pester test migration, and a database copilot.
- What you can do after
- Practice writing and refining prompts for specific tasks, then review the responses and adjust instructions or examples.
WordPress Power Toolkit: Harness AI to build next-level websites
A prompt is an instruction or question supplied to an AI system to elicit a response or generated content.
- How it is used
- Directs AI toward website planning, writing, design ideas, and critique through requests tailored to the task.
- How deep it goes
- Works through role, job, context, and format, then shows follow-up corrections and refinement rather than technical model internals.
- Examples
- Uses a bass-fishing site-title dialogue, a bakery-writing comparison, and home-page image prompts to show how detail changes results.
- What you can do after
- Practice/perform prompt writing and refinement for website tasks while judging which AI suggestions need further work.
Read how WordPress Power Toolkit: Harness AI to build next-level websites explains prompt →
Build a Website with ChatGPT
A prompt is a natural-language instruction or request supplied to an artificial-intelligence model to guide its response.
- How it is used
- Directs ChatGPT to suggest content and generate web page code within a prompt-copy-save-deploy workflow.
- How deep it goes
- Walks through specifying page content and formatting, checking results, testing code, and revising requests; does not explain model internals.
- Examples
- Uses a Hello World request, an online journal page prompt, and role-based questions about bread baking.
- What you can do after
- Apply it via ChatGPT to request, refine, and test code for web pages before saving and deploying them.
Grokking AI Applications
A prompt is an instruction or input provided to a generative AI model to elicit a response or guide content generation.
- How it is used
- Uses prompts to supply tasks, context, and behavioral guidance to LLMs within generative AI applications.
- How deep it goes
- Explains prompt length and a four-part template, then identifies enhancement techniques for improving responses.
- Examples
- Illustrates prompts with a pirate chatbot, a name-recall exchange, and a chef-and-dietitian recipe workflow.
- What you can do after
- Apply it via Langflow to guide model responses and build workflows with prompt components.
Generative AI in Action
A system prompt is an instruction supplied to a generative model that establishes behavior, information, or constraints for its responses.
- How it is used
- Uses system messages to establish assistant behavior, context, and constraints for chat and nonchat API requests.
- How deep it goes
- Explains message placement and prompt components through API examples and iterative refinements, including grounding and token management.
- Examples
- Shows translation, pet-only conversation, grounded question answering, and entity extraction into a specified JSON format.
- What you can do after
- Apply it via the chat completion API to guide assistant behavior and refine output instructions.
Introduction to Generative AI, Second Edition
A prompt is the text or other input supplied to a generative model to specify or guide the output it should produce.
- How it is used
- Uses prompts to guide generative models on tasks without retraining them.
- How deep it goes
- Defines prompts and explains their composition, refinement and limitations, with a comparison to post-training.
- Examples
- Uses article classification, targeted summaries, confidential contract revision and concise chatbot answers to illustrate prompts and their risks.
- What you can do after
- Evaluate how prompt wording, examples and context guide responses, and recognize privacy and injection risks.
Read how Introduction to Generative AI, Second Edition explains prompt →
AI Agents and Applications
A system prompt is an instruction message supplied to a language model to establish high-level behavior or constraints.
- How it is used
- Guides model behavior and tool selection across question-answering and agent workflows.
- How deep it goes
- Shows message construction and agent-node invocation, including how to inspect tool calls during debugging.
- Examples
- Uses a phishing reminder, a beach-town weather assistant, and a travel-request router.
- What you can do after
- Apply it via the OpenAI API or LangGraph to guide an assistant’s behavior and tool use.
Prompt Engineering in Practice
A prompt is an instruction and context artifact supplied to a model to specify a task, constraints, and expected output.
- How it is used
- Specifies model tasks, constraints, inputs, and output formats for software workflows.
- How deep it goes
- Works through a componentized incident-summary prompt and a management lifecycle; defers deployment pipelines, telemetry backends, and multimodel routing.
- Examples
- Uses an incident-report template and an HR policy chatbot’s conflicting instructions to show design and failure.
- What you can do after
- Practice/perform it: draft, test, review, deploy, and retire a prompt through a structured lifecycle.
Vibe Engineering
A prompt is an input instruction or request supplied to an AI model to elicit a response or action.
- How it is used
- Uses prompts to direct coding, data analysis, SQL generation, and deployment while controlling the model's assumptions.
- How deep it goes
- Explains prompt construction through labeled examples, explicit constraints, and an implemented SQL prompt, then checks generated results.
- Examples
- Uses a labeled authentication code set and a pharmaceutical notebook request to illustrate prompt design.
- What you can do after
- Apply prompts to coding and analysis tasks with explicit context and constraints, then evaluate generated outputs.
Build AI-Enhanced Web Apps
A basic text prompt is a single string containing instructions or questions for an AI model.
- How it is used
- Guides model responses to single-turn requests in AI web applications.
- How deep it goes
- Explains prompt formats, tokenization, and few-shot construction with SDK examples.
- Examples
- Uses a name question, a programming-language list, and customer support interactions to illustrate prompts.
- What you can do after
- Apply it via the Vercel AI SDK’s generateText function and refine instructions using examples.
Build a Text-to-Image Generator (from Scratch)
A text prompt is a natural-language instruction or description that specifies desired generated content.
- How it is used
- Guides image retrieval or conditions text-to-image generation from a natural-language description.
- How deep it goes
- Traces tokenization, padding, embeddings, and downstream generation with implementation examples; uses pretrained components rather than training them from scratch.
- Examples
- Uses a beach-playing dog for retrieval, a lion and tiger for encoding, and an astronaut riding a unicorn for generation.
- What you can do after
- Apply it via StableDiffusionPipeline to generate images and inspect how CLIP tokenizes and embeds the input.
Read how Build a Text-to-Image Generator (from Scratch) explains prompt →
Effective Conversational AI
A prompt is an input supplied to a language model that provides a task, instructions, context, or other conditioning information.
- How it is used
- Guides language-model responses in conversational assistants and supports designing, improving, and testing dialogue flows.
- How deep it goes
- Works through prompt assembly, iterative instructions, simulated conversations, and extraction examples, while showing where prompting alone fails.
- Examples
- Uses a recipe request, an empathetic airline greeting, insurance-claim dialogues, simulated users, and transcript-to-JSON extraction.
- What you can do after
- Practice/perform prompt iteration for conversational tasks, then test outputs against user effort, required fields, and failure cases.
Data Storytelling with Altair and AI
A prompt is an input text that provides instructions to a generative AI system about the content or operation to produce.
- How it is used
- Guides generative AI to create textual context, images, code suggestions, and possible next steps for data stories.
- How deep it goes
- Defines prompts and develops reusable structures for ChatGPT and DALL-E, while deferring detailed prompt-engineering guidance.
- Examples
- Uses fragility-title variants, sports chart titles, generated icons, campaign sharing options, and population-policy ordering.
- What you can do after
- Apply it via ChatGPT, DALL-E, and Copilot by specifying output goals, refining results, and checking generated proposals.
Read how Data Storytelling with Altair and AI explains prompt →
Build Python Web Apps with Streamlit
A prompt is an input supplied to a language model, typically consisting of one or more conversational messages.
- How it is used
- Uses prompts to guide model responses in trivia generation and customer support.
- How deep it goes
- Defines message roles and works through prompt construction, templating, and insertion into a graph workflow.
- Examples
- Uses a short Streamlit explanation, a seeded trivia question template, and an on-topic customer-support instruction.
- What you can do after
- Apply it via OpenAI’s Python library or LangGraph to send instructions and conversation context to a model.
Read how Build Python Web Apps with Streamlit explains prompt →
The Complete Obsolete Guide to Generative AI
A prompt is an input instruction or context supplied to a generative artificial-intelligence model to elicit an output.
- How it is used
- Guides generative-model outputs for chat, document queries, media creation, API calls, and automation.
- How deep it goes
- Defines prompts through concrete refinement strategies, contextual injection, and configuration, while deferring broader API capabilities to reference documentation.
- Examples
- Demonstrates constrained science and email requests, customer-support wording, document-grounded Sherlock Holmes queries, contracts, and image descriptions.
- What you can do after
- Apply it via interactive tools or APIs to request focused outputs, refine failed results, and constrain format and context.
Read how The Complete Obsolete Guide to Generative AI explains prompt →
Starting Data Analytics with Generative AI and Python
An input instruction or contextual payload that directs a generative AI system to produce a response.
- How it is used
- Directs generative AI to support analytics tasks with questions, context, and output requirements.
- How deep it goes
- Provides practical prompt-writing and refinement guidance while avoiding model architecture details.
- Examples
- Uses Portuguese customer reviews for keyword generation and direct sentiment classification.
- What you can do after
- Apply prompts via the ChatGPT API to generate review keywords, then inspect the output and adjust the request.
Read how Starting Data Analytics with Generative AI and Python explains prompt →
Data Analysis with LLMs
A textual instruction supplied to a language model that specifies a task, context, inputs, and often the desired output format.
- How it is used
- Directs a language model to classify data or translate questions into queries by supplying the task, inputs, and relevant context.
- How deep it goes
- Defines prompt components and works through reusable templates and multimodal inputs, without descending into model internals.
- Examples
- Uses labeled laptop reviews, a movie-review sentiment question, a database schema and question, and image-based questions.
- What you can do after
- Apply it via OpenAI’s Python library to generate prompts from templates, submit them, and collect classifications.
LLM Evaluation and Alignment, The Foundational Ideas
A system prompt is an instruction supplied to a language model that establishes standing behavior or constraints for an assistant.
- How it is used
- Establishes standing assistant instructions alongside user queries and retrieved knowledge in RAG.
- How deep it goes
- Defines the prompt’s role and describes its place in an instruction hierarchy, without detailing model implementation.
- Examples
- Uses a generalized RAG pipeline to distinguish standing instructions from a user query and retrieved knowledge.
- What you can do after
- Enables readers to evaluate and understand how standing instructions differ from queries and retrieved evidence in a RAG system.
Read how LLM Evaluation and Alignment, The Foundational Ideas explains prompt →
Machine Learning Platform Engineering
A system prompt is an instruction supplied to a language model to establish its role, behavioral constraints, and response requirements.
- How it is used
- Directs a documentation assistant’s role, scope, answer format, and use of retrieved context.
- How deep it goes
- Develops five prompt functions, contrasts a vague baseline with explicit rules, and shows managed-template integration.
- Examples
- Contrasts a generic documentation-assistant instruction with a scoped prompt and creates a templated Langfuse chat prompt.
- What you can do after
- Apply it via Langfuse to version, fetch, compile, and track a documentation assistant’s system prompt.
Read how Machine Learning Platform Engineering explains prompt →
Natural Language Processing in Action, Second Edition
A prompt is an input sequence of instructions or tokens supplied to a language model to guide its generated output.
- How it is used
- Guides generative chatbot replies through instructions, user messages, and conversational context.
- How deep it goes
- Works through prompt templates and conversation history, then tests outputs for unwanted turns and incorrect answers.
- Examples
- Uses a math tutor’s greeting, parental-permission flow, and number-sequence quiz to demonstrate prompting and its limits.
- What you can do after
- Apply it via LangChain to assemble chatbot prompts and inspect generated replies for errors.
Read how Natural Language Processing in Action, Second Edition explains prompt →
Local Image Generation
A prompt is a textual conditioning input that specifies desired content or characteristics for a generative model's output.
- How it is used
- Directs Stable Diffusion text-to-image generation and supports iterative image refinement.
- How deep it goes
- Defines prompts, compares phrasing outcomes, and traces CLIP conditioning nodes without detailing encoder internals.
- Examples
- Uses coffee descriptions, a sci-fi spaceship wallpaper, ramen workflows, and space man and cowboy evaluation prompts.
- What you can do after
- Apply it via A1111 or ComfyUI to phrase, revise, and batch-test image descriptions.
Spring AI in Action
A prompt is input supplied to a language model to elicit a generated response, potentially including text and image context.
- How it is used
- Uses prompts to connect Spring applications with language models for questions, generation, summarization, classification, moderation, translation, and sentiment analysis.
- How deep it goes
- Explains prompt construction, provider abstraction, message roles, templates, and REST integration, while deferring broader conversations and tool interactions.
- Examples
- Demonstrates question answering, board-game rules, role-separated messages, sentiment scoring, document summarization, translation, and image-generation descriptions.
- What you can do after
- Apply it via Spring AI ChatClient to submit user input, add system instructions, and expose generated results through REST services.
Claude at Work
A prompt is an input message that specifies a question, instruction, or requested task for an AI system.
- How it is used
- Directs Claude’s conversational work, from exploring a task to requesting and revising deliverables.
- How deep it goes
- Explains opening-prompt structure and follow-up corrections, without prescribing a fixed formula.
- Examples
- Uses an architecture sketch and design-document revisions, plus a cloud-migration question, to illustrate requests.
- What you can do after
- Apply it via Claude to frame a task, review the response and refine the output through follow-up requests.
Machines that Think
A prompt is an input instruction or context supplied to an artificial system to elicit a response or guide its behavior.
- How it is used
- Frames language-model tasks and supplies immediate context for generation.
- How deep it goes
- Explains probabilistic continuation, context limits, and prompt sensitivity, including the difficulty of assessing revisions without objective feedback.
- Examples
- Illustrates sensitivity through formatting variations and prompt refinement through a classification exercise without correct answers.
- What you can do after
- Evaluate prompt-dependent responses against independent evidence while recognizing that fluency and apparent compliance do not guarantee correctness.
The Art of AI Product Development
A prompt is an instruction or contextual input supplied to a generative model to elicit an output.
- How it is used
- Uses prompts to direct content generation, incorporate retrieved information, and constrain an editing assistant’s responses.
- How deep it goes
- Explains prompt components and reusable templates, then applies prompts to retrieval context and an off-topic safeguard.
- Examples
- Uses an AI-compliance content creator role and an editing assistant that declines unrelated requests.
- What you can do after
- Apply prompting by assembling reusable templates and choosing context for generation tasks.
Read how The Art of AI Product Development explains prompt →
Build an AI Agent (From Scratch)
An instruction supplied to a language model that establishes high-level behavior or constraints for an interaction.
- How it is used
- Defines persistent behavioral instructions for agents while distinguishing them from user requests and broader context.
- How deep it goes
- Moves from prompt categories to practical action and tool-use guidelines, then examines the limits of packing multiple roles into one prompt.
- Examples
- Uses a search-ready agent and a technical blog assistant divided into research, coding, writing, and review roles.
- What you can do after
- Apply prompt design guidelines to specify agent behavior, clarification rules, and tool-use triggers.
Fight Fraud with Machine Learning
A prompt is text supplied to a generative language model as the conditioning input for producing an output.
- How it is used
- Guides GPT text generation, constrains ChatGPT phishing verdicts, and triggers DONUT document-text extraction.
- How deep it goes
- Explains autoregressive next-token generation and implements a decoder trigger prompt, without detailing prompt-optimization methods.
- Examples
- Illustrates constrained phishing and genuine-email verdicts plus Slovakian-ID extraction initiated by <s>.
- What you can do after
- Apply it via ChatGPT for constrained phishing verdicts and via DONUT to initiate ID-text extraction.
Read how Fight Fraud with Machine Learning explains prompt →
The Quick Python Book, Fourth Edition
A prompt is an instruction or input supplied to an AI system to elicit a particular response or generated output.
- How it is used
- Uses prompts to request and refine AI-generated Python solutions to programming exercises.
- How deep it goes
- Gives procedural guidance for specifying requirements, supplying existing code, evaluating results, and refining requests.
- Examples
- Uses temperature statistics, word counting, wc-style refactoring, and weather-data extraction as prompting tasks.
- What you can do after
- Practice creating and refining prompts for AI-generated Python code, then evaluate and test the results.
Read how The Quick Python Book, Fourth Edition explains prompt →
Deep Learning with Python, Third Edition
A short text description used to condition image generation, including both positive and negative forms in this section.
- How it is used
- Uses prompts to condition image generation and steer results toward desired content or away from unwanted content.
- How deep it goes
- Explains text encoding, denoising, and embedding interpolation, while using a pretrained model instead of training a text-to-image model from scratch.
- Examples
- Uses an astronaut on an origami elephant, a negative prompt for blue, and interpolation between a dog and a tentacled creature.
- What you can do after
- Apply prompts via KerasHub’s TextToImage task and explore images generated from interpolated prompt embeddings.
Read how Deep Learning with Python, Third Edition explains prompt →
Building LLM Applications with DSPy
Textual instructions or input supplied to a language model to elicit a response.
- How it is used
- Provides task instructions and input to a language model, with DSPy generating prompts from signatures and modules.
- How deep it goes
- Explains prompt sections, role separation, generation, inspection, and evaluation, including custom instruction changes and optimization costs.
- Examples
- Uses an intent-classification baseline and a custom module that appends an instruction to a question-answering prompt.
- What you can do after
- Apply it via DSPy to generate and inspect prompts, compare candidates, and modify instructions in a custom module.
Read how Building LLM Applications with DSPy explains prompt →
LLMs in Production
A persistent prompt instruction applied to requests to establish consistent model behavior or interaction style.
- How it is used
- Guides consistent application behavior by combining recurring instructions with user requests and supporting context.
- How deep it goes
- Explains prompt components and refinement, then illustrates retrieval, example formatting, and context-window filtering in an API.
- Examples
- Uses a company-policy chatbot and a coding assistant with retrieved instruction-output examples.
- What you can do after
- Apply prompting by composing recurring instructions, user input, and context, then refining wording and examples.
Deep Learning with R, Third Edition
A prompt is an input specification that identifies the object or region for which an image-segmentation model should produce a mask.
- How it is used
- Directs Segment Anything to the object whose mask should be predicted.
- How deep it goes
- Explains the encoder–decoder pipeline and training triples, while deferring prompt-encoder and mask-decoder internals.
- Examples
- Uses a point inside an object or a box around it to specify the desired mask.
- What you can do after
- Evaluate and understand how a prompt guides mask prediction and how the prediction is compared with a label.
Read how Deep Learning with R, Third Edition explains prompt →
A Pythonic Adventure: From Python basics to a working web app
A prompt is an instruction or question supplied to an AI system to elicit a response.
- How it is used
- Uses precise role-based requests to obtain code reviews, explanations, corrections, and ideas from AI.
- How deep it goes
- Explains prompt precision through role, task, code, and follow-up examples, without covering prompt internals.
- Examples
- Uses a read_menu function, list-comprehension questions, a TypeError traceback, and analogy questions as prompt examples.
- What you can do after
- Apply it via ChatGPT to request targeted programming help and continue with clarifying questions.
Read how A Pythonic Adventure: From Python basics to a working web app explains prompt →
Learn Generative AI with PyTorch
The chat message role that sets assistant behavior in the OpenAI chat-completions format.
- How it is used
- Sets assistant behavior in OpenAI chat-completions requests.
- How deep it goes
- Defines role and effect, then demonstrates several behavioral instructions without detailing internal model processing.
- Examples
- Uses factual answering, essay writing, joke telling, and follow-up conversation as concrete API examples.
- What you can do after
- Operate/configure an OpenAI chat completion with a behavior-setting system message and a user request.
AI Model Evaluation
A prompt is text or other input provided to a generative model to specify a task or elicit a response.
- How it is used
- Uses prompts to frame LLM-as-a-judge tasks and define what evidence and criteria the judge can consider.
- How deep it goes
- Details prompt components and iteration steps, including rubrics, structured output, baseline testing, and versioning.
- Examples
- Contrasts an underspecified movie-recommendation judging prompt with the need for explicit relevance, diversity, and output criteria.
- What you can do after
- Apply prompt design to an LLM-as-a-judge evaluation by specifying context, criteria, and output, then testing and revising the baseline.
AI Agents in Action
A system prompt is a high-priority instruction supplied to a language model to establish its behavior, role, and response constraints.
- How it is used
- Uses system prompts to establish model behavior in chat requests and agent personas.
- How deep it goes
- Defines message roles and illustrates system instructions in API requests, agent profiles, and question-answer templates.
- Examples
- Uses a helpful assistant request, an ogre-speaking persona, and a context-based question-answer template.
- What you can do after
- Apply system prompts via chat completions requests and agent profiles to specify roles and response rules.
Crack Any Codebase with AI
A prompt is an instruction or input supplied to an AI model to elicit a particular response.
- How it is used
- Turns AI-assisted code exploration into a sequence of questions that produce checkable summaries, diagrams, numbers, and trade-offs.
- How deep it goes
- Defines prompt constraints and demonstrates them with code questions, but stops short of specifying a general prompt language or model internals.
- Examples
- Uses one-sentence summaries, Mermaid sequence diagrams, schema alternatives, toy examples, nanoGPT, Cal.com, and Ghost git history.
- What you can do after
- Apply it via chat to interrogate selected files, trace flows, test claims, compare design alternatives, and record durable learning notes.
Effective Data Analysis
A prompt is user-provided input that instructs a generative model about the content or behavior expected in its output.
- How it is used
- Directs generative AI toward defined analytics tasks and stakeholder-relevant outputs.
- How deep it goes
- Defines prompts operationally and demonstrates refinement, but does not explain model internals or training.
- Examples
- Uses login statistics, rats_weather.csv, predictive models, Python code, and city-agency recommendations as prompt-driven examples.
- What you can do after
- Apply it via ChatGPT or another chatbot to request analyses, code, models, metrics, and constrained recommendations.
Enterprise RAG
A prompt is an instruction or input supplied to a language model to guide the content or form of its output.
- How it is used
- Guides search agents and writer agents so retrieved business data becomes a controlled, user-facing answer.
- How deep it goes
- Develops prompts from basic search instructions to detailed writer policies, while deferring general prompt theory.
- Examples
- Uses search prompts, detailed writer prompts, retrieved records, and Wongza-specific ranking instructions as concrete examples.
- What you can do after
- Apply via Python and AutoGen by constructing search plans, passing retrieved data to a writer agent, and refining instructions from feedback.
AI Agents in Action, Second Edition
A prompt is an instruction or contextual input supplied to a language model to guide the content and behavior of its response.
- How it is used
- Uses prompts to make language-model agents predictable, productive, cost-aware, and reliable.
- How deep it goes
- Explains prompt structure, caching, failure modes, and SDK boundaries, but stops short of model internals.
- Examples
- Uses a research-agent prompt, persona and delimiter patterns, caching placement, and a retrieval-agent output-format correction.
- What you can do after
- Build it from scratch by writing structured prompts, decomposing overloaded tasks, and adapting instructions around SDK-provided metadata.
Read how AI Agents in Action, Second Edition explains prompt →
Designing AI Systems
An instruction or input supplied to an AI model to elicit a response or behavior.
- How it is used
- Centralizes reusable model instructions so workflows can retrieve, test, and update prompts without embedding copies in application code.
- How deep it goes
- Explains prompt registration, metadata, versioning, retrieval, and comparative evaluation, but does not specify prompt syntax.
- Examples
- Uses patient intake instructions, formal and conversational prompt variants, and a personal assistant system prompt.
- What you can do after
- Operate a prompt registry, retrieve named prompts in workflows, and compare variants against a shared evaluation dataset.
Microsoft Azure in Action
A prompt is text or other input instructions supplied to a generative model to guide its output.
- How it is used
- Guides Azure OpenAI text generation for tasks such as recommendations, summaries, and answers.
- How deep it goes
- Shows a worked prompt and its request field, but does not develop a general prompt-writing procedure.
- Examples
- Uses a customer review of *1984* to request three book recommendations with brief descriptions.
- What you can do after
- Apply it via an Azure OpenAI REST request to ask a deployed model for tailored recommendations.
Context Engineering
A prompt is an input supplied to a language model to elicit a response or guide its behavior.
- How it is used
- Uses user prompts to express immediate intent and guide context selection toward a specific outcome.
- How deep it goes
- Explains four prompt design principles and surveys techniques, frameworks, and production safeguards.
- Examples
- Contrasts a broad definition question with a constrained request specifying audience, length, focus, and tone.
- What you can do after
- Apply prompt design principles to specify tasks and output formats, and manage templates with version control and regression testing.
AI-Powered Developer: Build software with ChatGPT and Copilot
A natural language prompt is an instruction or query expressed in ordinary human language for directing an AI system.
- How it is used
- Directs ChatGPT, Copilot, and CodeWhisperer toward code, explanations, debugging, refactoring, or architectural assistance.
- How deep it goes
- Explains prompts as model inputs and develops context-sensitive refinement through coding examples, without detailing model internals.
- Examples
- Uses linked-list reversal, kth-smallest selection, Flask setup, dashboard creation, memory-leak analysis, and refactoring requests.
- What you can do after
- Apply it via ChatGPT, GitHub Copilot, or CodeWhisperer to request code and refine requirements toward a desired result.
Read how AI-Powered Developer: Build software with ChatGPT and Copilot explains prompt →
Sutskever's List
A prompt is an input containing instructions, examples, or context provided to a model to elicit a response.
- How it is used
- Uses prompts to reveal existing model capabilities and support more reliable multistep reasoning.
- How deep it goes
- Moves from puzzle failures to explicit state representations and chain-of-thought prompting.
- Examples
- Uses a changed-rules river-crossing puzzle, state triples, and stepwise math or logic problems.
- What you can do after
- Apply explicit state tracking or chain-of-thought prompts to improve multistep reasoning without additional training.
Time Series Forecasting Using Foundation Models
A system prompt is an instruction supplied to a language model that establishes its context, behavior, tone, or response constraints.
- How it is used
- Frames forecasting, anomaly detection, and contextual time-series modeling as language-model tasks.
- How deep it goes
- Explains prompt roles, formatting, API delivery, and output parsing, but defers robust safeguards and model internals.
- Examples
- Uses comma-separated sequences, forecast requests, anomaly labels, weekly sales context, and daily website-visit seasonality.
- What you can do after
- Apply it via API calls or Time-LLM configuration to provide context, request forecasts, and constrain model output.
Read how Time Series Forecasting Using Foundation Models explains prompt →
Regular Expression Puzzles and AI Coding Assistants
Prompt phrasing is the particular wording and structure used to formulate an instruction for an AI system.
- How it is used
- Frames requests to AI coding assistants while evaluating generated regular expressions and functions.
- How deep it goes
- Examines wording changes through concrete outputs and counterexamples, while deferring any general method for finding optimal prompts.
- Examples
- Uses IPv4 matching, domino-pattern matching, poker-hand pair detection, and function naming outputs.
- What you can do after
- Evaluate/understand how alternate requests and surrounding context can change AI-generated code without guaranteeing correctness.
Read how Regular Expression Puzzles and AI Coding Assistants explains prompt →
Self-Improving Agents
Text supplied to a language model as instructions or input for an interaction.
- How it is used
- Improves the instruction artifact that drives a RAG agent without retraining its model.
- How deep it goes
- Shows prompt variants being judged and retained as versions, while leaving model weights unchanged.
- Examples
- Uses a support-agent return question and adds an instruction to begin with a direct yes or no.
- What you can do after
- Apply it via Helix, an LLM-as-Judge, and SPO to improve a RAG agent's prompt offline.
Deep Learning with PyTorch, Second Edition
User-provided guidance such as points, boxes, or masks that steers the segmentation model toward a desired object or region.
- How it is used
- Guides image generation, inpainting, and segmentation toward specified content or regions.
- How deep it goes
- Distinguishes prompt roles and demonstrates invocation, while deferring model internals and prompt-generation details.
- Examples
- Uses a horse-to-zebra edit and segmentation inputs consisting of points, boxes, or masks.
- What you can do after
- Apply prompts through an inpainting pipeline or use them to guide segmentation masks without task-specific fine-tuning.
Read how Deep Learning with PyTorch, Second Edition explains prompt →
Reinforcement Learning from Human Feedback
A prompt is an input text or instruction provided to a language model to elicit a response.
- How it is used
- Structures model context for interaction, training, evaluation, RLHF rollouts, chat formatting, and tool use.
- How deep it goes
- Explains prompt effects, role formatting, RLHF structure, tool calls, and evaluation examples without deriving prompting algorithms.
- Examples
- Uses pirate-style system instructions, helicopter questions, multiple-choice reasoning prompts, tool schemas, and Fibonacci code execution.
- What you can do after
- Apply it via chat templates, RLHF datasets, evaluation prompts, and tool-orchestration loops.
Read how Reinforcement Learning from Human Feedback explains prompt →
Architecting for Autonomy
An instruction or contextual input supplied to a generative model to elicit a response or action.
- How it is used
- Uses agent instructions to shape legal-agent behavior while distinguishing guidance from proof of policy compliance.
- How deep it goes
- Explains prompt limitations and governance controls, but does not specify prompt formats or implementation details.
- Examples
- Uses a legal-agent instruction set covering privilege, applicable authorities, allegations versus facts, and lawyer approval.
- What you can do after
- Evaluate whether instructions are backed by independently verifiable policy controls.
Building Reliable AI Systems
Input instructions or context supplied to an AI model to guide its response.
- How it is used
- Uses prompts as instructions and quality contracts for consistent model behavior in applications.
- How deep it goes
- Explains prompt components and production expectations through examples, with a version-selection sketch.
- Examples
- Contrasts open-ended and one-sentence ocean prompts, and applies retrieved policy excerpts to health-care question answering.
- What you can do after
- Apply it to specify response behavior and incorporate retrieved context into a question-answering prompt.
How Large Language Models Work
A prompt is an input text or other input provided to a language model to elicit an output.
- How it is used
- Constrains language-model behavior toward a particular task, format, tone, and set of goals.
- How deep it goes
- Defines prompting and explains framing sensitivity, but defers detailed prompt construction and model internals.
- Examples
- Uses CSV conversion, survey-theme categorization, car-salesperson roleplay, and stylized writing as examples.
- What you can do after
- Apply it by framing bounded inputs for data processing, categorization, or stylized generation while limiting unpredictable requests.
Get Programming: Learn to code with Python
A prompt is text displayed by a program to request information from a user.
- How it is used
- Uses prompts to begin interactive programs and collect information that guides later operations.
- How deep it goes
- Explains display, waiting, spacing, storage, string handling, and numeric conversion through short code examples.
- Examples
- Uses name, location, secret, color, symbol, and number questions, including stored responses and calculations.
- What you can do after
- Apply it via Python's input() function to request, store, transform, and calculate with user responses.
Read how Get Programming: Learn to code with Python explains prompt →
Digital Twins in Action
A system prompt is a high-level instruction supplied to a model that establishes an agent's role, behavior, and constraints.
- How it is used
- Guides a home climate-control agent’s decisions with role instructions, priorities, and consumption assumptions.
- How deep it goes
- Defines the system prompt and illustrates its structure with a concrete control policy.
- Examples
- Uses a climate-control prompt with temperature targets, electricity-load assumptions, control states, and hysteresis.
- What you can do after
- Evaluate and understand how a prompt expresses an agent’s priorities and operating assumptions.
Snowflake Data Engineering
A prompt is a set of questions or instructions and supporting context supplied to a generative model to guide its output.
- How it is used
- Guides an LLM through extracting structured records from unstructured email within a Snowflake data pipeline.
- How deep it goes
- Defines prompt engineering and demonstrates iterative, schema-constrained construction, but does not explain LLM internals.
- Examples
- Uses bakery delivery emails, constrained bakery items, five CSV columns, and YYYY-MM-DD date formatting.
- What you can do after
- Build it from scratch by writing prompts that produce structured LLM output for downstream transformation and storage.
AI-Powered Search
A prompt is input text supplied to a language model to provide instructions, questions, or contextual material.
- How it is used
- Constructs context and instructions for foundation models that summarize retrieved search results.
- How deep it goes
- Explains contextual token interpretation and prompt assembly, but defers Transformer implementation details.
- Examples
- Uses retrieved web results, URLs, citation markers, and a “Be concise” instruction to demonstrate summarization.
- What you can do after
- Apply it via a search pipeline by combining a query, retrieved results, citations, and output instructions.
LLM Customization and Fine-Tuning
The input supplied to a model, potentially containing instructions, context, and examples.
- How it is used
- Uses prompts to test production behavior and to generate diverse inputs for model distillation and preference training.
- How deep it goes
- Explains prompt validation, diversity, and message-list formatting, but does not prescribe specific instruction wording.
- Examples
- Uses paraphrased production queries, expert seed questions, and a browser-command preference pair.
- What you can do after
- Evaluate prompts with held-out tests, repeated runs, and brittleness checks; generate diverse queries for distillation.
Read how LLM Customization and Fine-Tuning explains prompt →
Modern Angular
A prompt is text supplied to an AI system as an instruction or question that guides its generated response.
- How it is used
- Uses ChatGPT to accelerate Angular unit-test preparation, especially mock data, service dependencies, and component tests.
- How deep it goes
- Explains prompt specificity through technology references and constraints, but stops short of a general prompt-engineering framework.
- Examples
- Demonstrates typed TimeOffRequest arrays, TimeOffRequestService mocks, and generated ConfirmationDialogComponent tests.
- What you can do after
- Apply it via ChatGPT to generate test fixtures, dependency mocks, and candidate Angular unit tests.
Grokking AI Algorithms, Second Edition
A prompt is an instruction, question, or other text input provided to a language model to elicit a response.
- How it is used
- Uses text directions to guide language and image models toward useful generated content.
- How deep it goes
- Explains prompts as model guidance and shows their role in generation, but does not develop prompt-engineering techniques.
- Examples
- Uses scene descriptions, article outlines, slogans, reports, product descriptions, practice questions, and lesson summaries.
- What you can do after
- Apply it via a language or image model to create a first draft or generate visual content for human refinement.
Read how Grokking AI Algorithms, Second Edition explains prompt →
Financial AI in Practice
A prompt is an instruction or input supplied to a generative model to guide its output.
- How it is used
- Guides LLM output for financial products, including personalized investment summaries and portfolio allocation recommendations.
- How deep it goes
- Shows prompt formatting and API calls, while leaving complex production RAG infrastructure beyond the illustrative examples.
- Examples
- Uses investment-post summaries and prompts combining macroeconomic data, ETF signals, and current portfolio weights.
- What you can do after
- Build it from scratch by formatting financial inputs into a prompt and passing it to an LLM API.
Build Applications with Local AI Models on a Mac
An input instruction or request submitted to an AI model for processing.
- How it is used
- Provides the input an AI model processes to produce a response.
- How deep it goes
- Defines prompts and names input forms without explaining how to design them.
- Examples
- Names questions, instructions, voice transcripts, and blocks of text as prompt forms.
- What you can do after
- Apply prompts through Python’s Ollama API to send input to a local model and receive responses.
Read how Build Applications with Local AI Models on a Mac explains prompt →
Also covered in
- Learn AI Data EngineeringIn early access (MEAP)
- Knowledge Graphs and LLMs in Action
- Learn AI-Assisted Python Programming, Second Edition
- Investing for Programmers
- Essential GraphRAG
- Troubleshooting Java, Second Edition
- The AI Pocket Book
- The Architecture of ReasoningIn early access (MEAP)
- AI Agents for Offensive SecurityIn early access (MEAP)
- Agent Design PatternsIn early access (MEAP)
- Causal AI
- Grokking Relational Database Design
What to know first
- language modelA language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
- ChatGPTChatGPT is OpenAI’s conversational AI service, which lets users interact with generative AI models and related tools through natural-language prompts.
- contractA contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
- conversational aiConversational AI is artificial intelligence that enables software systems to interpret user input and interact with users through natural-language dialogue.
Related concepts
- prompt engineeringused by · Prompt engineering is the deliberate design and refinement of inputs, instructions, and context to guide an AI model’s behavior or outputs.
- language modeluses · A language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
- contexthas part · Context is the relevant information, state, or circumstances surrounding an input, decision, or activity that influence its interpretation or behavior.
- ChatGPTuses · ChatGPT is OpenAI’s conversational AI service, which lets users interact with generative AI models and related tools through natural-language prompts.
- ai coding assistantused by · An AI coding assistant is a software tool or agent that uses artificial intelligence to help create, modify, explain, test, or review computer code.
- prompt componenthas part · A prompt component is a distinct part of a prompt that provides information, instructions, examples, or other content for a particular function.
Questions about prompt
What is prompt?
A prompt is text or other input supplied to an AI model to provide instructions, context, or other information that guides its response or generated output.
Which Manning books explain prompt?
Software Testing with Generative AI, Coding with AI, AI for Everyday IT, WordPress Power Toolkit: Harness AI to build next-level websites, Build a Website with ChatGPT, Grokking AI Applications, Generative AI in Action, Introduction to Generative AI, Second Edition and 56 more.
What should I know before learning prompt?
Manning books that teach prompt usually introduce language model, ChatGPT, contract and conversational ai first.
What are the parts of prompt?
Prompt includes context and prompt component.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.































































