AI tools default to generic formats that rarely match what you actually need. Learn how to explicitly control output structure, length, and detail level so every AI response fits your workflow from the first try.

You've asked an AI tool for a summary of last quarter's sales performance, and it came back with six paragraphs of flowing prose when you needed a five-bullet executive brief. Or you asked for a data dictionary and got a plain wall of text instead of a formatted table. Sound familiar? The frustration isn't that the AI got the content wrong — it's that it delivered the right information in completely the wrong package.
This is one of the most common friction points for people new to working with AI tools, and it's entirely fixable. AI models don't have a default notion of what "good output" looks like for your specific situation. They make educated guesses based on your prompt, the platform, and the patterns they've seen in training data. When you don't tell them what format you want, they default to something generic — usually verbose, conversational prose that may be great for some contexts and useless for others.
By the end of this lesson, you'll know exactly how to control what your AI output looks like. That means telling the model how long the response should be, what structural format to use, how much detail to include, and even what to leave out. These aren't advanced tricks — they're foundational skills that will make every prompt you write more effective starting today.
What you'll learn:
No prior technical background is required. You should have access to any AI chat interface (ChatGPT, Claude, Gemini, or similar) and have experimented with at least a few basic prompts. If you haven't done that yet, the Prompt Engineering Fundamentals for Data Professionals lesson is a great starting point.
Before we get into techniques, it's worth understanding why this problem exists in the first place — because once you understand that, the solutions feel obvious rather than arbitrary.
Large language models are trained on enormous quantities of text from the internet, books, code repositories, and other sources. That text includes everything from academic papers to Reddit threads to API documentation. When you give a model a prompt, it generates a response that statistically fits the kind of output that tends to follow that type of input. If you write a prompt that looks like a question someone might type into a search engine, you'll probably get an encyclopedia-style answer. If your prompt looks like a business email, you'll get a business email back.
The model isn't making a conscious choice — it's pattern-matching. And the patterns it's matching against were written by humans who had wildly different formatting preferences. To learn more about how this process actually works under the hood, see Understanding Large Language Models: How ChatGPT and Claude Actually Work.
The practical implication is simple: the model will fill in format details you don't specify with its best guess, and its best guess is often wrong for your context. Your job as a prompt author is to close that gap by being explicit about what you want.
Key insight
Format instructions aren't optional polish on a good prompt — they're a core part of communicating your actual requirements. A technically correct response in the wrong format can be just as useless as a wrong answer.
When people talk about "format," they usually mean one of three things, often without realizing they're distinct:
You can control all three independently, and you often need to specify all three to get the response you actually want. Let's work through each one.
Structure is usually the most visible formatting problem. The fix is direct: name the structure you want.
When you need scannable, discrete items, ask for them explicitly.
Vague prompt:
What should I check when my Power BI report is loading slowly?
This will almost certainly produce multiple prose paragraphs. That might be fine if you're reading for understanding, but if you're running through a troubleshooting checklist, it's annoying to parse.
Structured prompt:
List the most common causes of slow Power BI report load times.
Format your response as a numbered checklist with no more than 10 items.
Each item should be a single actionable sentence.
The difference in usability is significant. Notice that the structured prompt specifies both what kind of list (numbered checklist) and constraints on each item (single actionable sentence). Both matter.
Use numbered lists when order or sequence matters — setup steps, ranked priorities, workflows. Use bullet lists when items are parallel but unordered — features, considerations, options.
Tables are incredibly useful for comparative information, data dictionaries, feature comparisons, and anything where you're laying out attributes across multiple items. AI models can produce excellent markdown tables, but they'll rarely generate one unless you ask.
Prompt:
I'm building a data dictionary for a customer orders table.
The table has these columns: order_id, customer_id, order_date,
ship_date, total_amount, status, region.
Create a data dictionary in a markdown table with these columns:
Field Name | Data Type | Description | Example Value | Notes
That prompt will produce a clean, structured table you can paste directly into documentation. Without the explicit table instruction, you'd get prose descriptions of each field.
Tip
If you're pasting AI-generated markdown tables into tools like Confluence, Notion, or GitHub, they'll render automatically. If you're working in Excel or a plain text environment, ask the model to use pipe-delimited format or CSV format instead.
If you're asking for code, SQL, DAX, Python, or any structured technical syntax, always specify the language. This triggers proper code block formatting and usually produces cleaner, more idiomatic output.
Prompt:
Write a SQL query to find all customers who placed more than 3 orders
in the last 90 days. Use PostgreSQL syntax. Return the result as a
formatted SQL code block with comments explaining each section.
The phrase "formatted SQL code block with comments" does double duty: it requests the structural format (code block) and the detail level (explanatory comments). For more on working with AI-generated code for data tasks, see Using AI to Generate SQL, DAX, and M Code: A Complete Guide for Data Professionals.
Sometimes you genuinely do want flowing prose, but organized — like a structured report or a written analysis. In those cases, ask for section headers explicitly.
Prompt:
Write a brief analysis of why customer churn tends to increase in Q3
for subscription businesses. Structure it with the following H2 headers:
"Common Causes," "Warning Signs in the Data," and "Retention Strategies."
Keep each section to 2-3 short paragraphs.
This gives you flowing text that's still navigable and organized.
Length control is where many people's prompts fall short. Saying "be concise" or "give me a detailed answer" is too vague — those words mean different things to different people, and they mean something yet again to an AI model.
Instead of vague qualifiers, give the model something measurable.
| Instead of this... | Try this... |
|---|---|
| "Be concise" | "Respond in no more than 3 sentences" |
| "Give me a detailed answer" | "Write at least 400 words covering all major subtopics" |
| "Keep it short" | "Use exactly 5 bullet points, each one sentence" |
| "Summarize this" | "Write a 2-sentence summary suitable for a Slack message" |
| "Explain thoroughly" | "Explain this concept with at least 3 examples and cover common misconceptions" |
Concrete constraints give the model a target to hit. It won't always land exactly on the number, but it will get close — and more importantly, it will stay in the right range.
Warning
Don't over-constrain length when the content genuinely varies. If you ask for a 2-sentence explanation of a complex regulatory framework, the model will produce two sentences — but they'll be so dense and compressed as to be unreadable. Match your length constraint to the actual complexity of the content.
You have several units available to you:
For most everyday prompting, bullet count and word count are your most reliable levers. "One page" is too ambiguous (what size page? what font?) and models don't truly understand physical page length. Word count is better.
These are different instructions and produce different behaviors.
A maximum constraint ("no more than 150 words") tells the model to stop early if it's running out of things to say rather than padding. This is useful for summaries, executive communications, and anywhere you're fitting into a constrained space.
A minimum constraint ("at least 300 words") tells the model not to gloss over the topic. This is useful when you know the subject deserves depth and you're worried the model will give you a superficial overview.
Using both together ("between 200 and 300 words") is the most precise, though for casual use it can feel like overkill. Reserve it for templated prompts you're going to reuse repeatedly.
Detail level is subtler than structure or length. It's about how deep the model goes — whether it stays at the surface of a topic or dives into the mechanics, edge cases, examples, and nuances.
The most effective way to control detail level is to specify your audience and describe what they already know.
Compare these two prompts:
Prompt A:
Explain what a foreign key is in a database.
Prompt B:
Explain what a foreign key is in a database.
I'm presenting this to a non-technical marketing team
who understands Excel but has never worked with SQL.
Prompt B will produce a completely different explanation — one with analogies, plain language, and no assumed technical vocabulary. The content (what a foreign key is) is the same, but the detail level and vocabulary are calibrated to the audience.
You can also specify audience in the other direction, toward more technical depth:
Explain the trade-offs between clustered and non-clustered indexes
in SQL Server. I'm an experienced data engineer who understands
B-tree structures, so skip the basics and focus on performance
implications at scale and common misuse patterns.
That prompt will get you a very different answer than a generic "explain indexes" prompt — richer, denser, and focused on the parts that actually matter for an experienced practitioner.
Key insight
Telling the model who you are (or who the audience is) is one of the highest-leverage format instructions you can give. It calibrates vocabulary, assumed knowledge, example complexity, and the level of "hand-holding" in the explanation all at once.
Examples significantly increase the utility of an explanation, but they also add length and shift the depth of coverage. Be explicit about whether you want them.
One of the most underused format techniques is telling the model what not to include. This is especially useful when you know the model tends to add boilerplate you don't need.
Explain how to calculate customer lifetime value (CLV).
Do NOT include an introduction paragraph — start directly
with the formula. Do NOT recommend consulting a data scientist.
Focus on what I can calculate in a spreadsheet.
That set of exclusions saves you from skimming past a paragraph of preamble and a paragraph of caveats to find the two sentences you actually came for.
Tip
If you find yourself regularly deleting the same kinds of AI output — opening pleasantries, unnecessary caveats, "I hope this helps!" endings — just add "Skip the preamble and start directly with [X]" and "No sign-off needed" to your prompt. You can even bake these into a reusable template.
The real power comes from combining structure, length, and detail level in a single, well-organized prompt. Here's what that looks like in practice.
Scenario: You need to send your VP of Sales a quick analysis of this month's pipeline coverage, with enough context to understand it but short enough to read in two minutes.
Prompt:
Analyze the following pipeline coverage data for Q3 and produce
an executive summary for a VP of Sales.
Data:
- Total pipeline value: $4.2M
- Quota: $2.8M
- Pipeline coverage ratio: 1.5x
- Last quarter coverage: 2.1x
- Stage breakdown: 40% early stage, 35% mid-stage, 25% late stage
- Average deal size: $85,000
Format requirements:
- Start with a 2-sentence executive summary (the "so what")
- Follow with 3-4 bullet points on key observations
- End with 2-3 specific recommended actions
- Total length: no more than 250 words
- Use plain business language — no jargon, no formulas
- Do NOT include raw data in the output (I'll attach the data separately)
Notice that the format requirements section is broken out clearly. When you have multiple constraints, listing them makes it easier for both you and the model to track. You're less likely to forget to include something, and the model is less likely to miss one of your instructions buried in a paragraph. For more on building reusable prompt formats like this, see Prompt Templates and Reusable Prompt Libraries: How to Standardize AI Inputs Across Your Team.
Work through each of these prompts. Try the "before" version first, then try the "after" version, and notice the difference in the output you get.
Exercise 1 — Length control:
Before:
What are the benefits of using Python for data analysis?
After:
List exactly 5 benefits of using Python for data analysis.
Format as a numbered list. Each item: one sentence, max 20 words.
No introduction, no conclusion.
Exercise 2 — Audience and detail level:
Before:
Explain what machine learning is.
After:
Explain what machine learning is to a CFO with no technical background.
Use a business analogy. Keep it to 3 short paragraphs.
Avoid all technical jargon. Focus on how it relates to business decisions.
Exercise 3 — Structure plus exclusions:
Before:
How do I set up a new data pipeline?
After:
Describe the steps to set up a data pipeline from a source database
to a reporting layer. Format as numbered steps. 10 steps maximum.
Each step: one clear action sentence plus one sentence of explanation.
Skip theoretical background — assume I know what a pipeline is.
Skip vendor recommendations — focus on the process, not the tools.
Exercise 4 — Full format specification:
Write a prompt asking for a comparison of three data storage options (data warehouse, data lake, data lakehouse) formatted as a markdown table with columns for Use Case, Pros, Cons, and Best For. Add a constraint that the entire table should take no more than 5 rows per option and use plain language.
Mistake 1: Using vague qualifiers instead of specific constraints
"Be concise," "thorough," "detailed," and "brief" are all subject to interpretation. The model's definition of "brief" might be 300 words. Yours might be 50. Use numbers.
Mistake 2: Putting format instructions at the end where they compete with content
If your prompt is long, format instructions buried in the last sentence often get partially ignored. Put a dedicated "Format:" or "Output requirements:" section in your prompt, or lead with the format requirement before the content request.
Mistake 3: Asking for a format the model can't deliver in your environment
Markdown tables look great in ChatGPT, Claude, and Notion. They look like | pipes | and | dashes | in a plain text email. Know where your output is going before you specify the format.
Warning
Some platforms strip or don't render markdown. If you're copying AI output into a tool that doesn't support markdown, ask for plain text formatting instead — or ask the model to output it in a format your tool accepts.
Mistake 4: Forgetting to specify what NOT to include
The model will add an introduction, a conclusion, disclaimers, and pleasantries unless you tell it not to. When you're building a reusable prompt or automated workflow, those extras are waste. Be explicit about exclusions.
Mistake 5: Conflating structure with detail level
Asking for bullet points doesn't automatically make the content shallower. You can have deeply detailed bullets or shallow prose. These are independent dials. If you want scannable and shallow, ask for both: "5 bullet points, each one sentence, high-level only."
Troubleshooting: The model ignores your format instructions
If you specify a format and the model ignores it, try these in order:
Format instructions are not decoration — they're a core part of every effective prompt. When you specify structure, length, and detail level explicitly, you stop getting generic AI output and start getting output that actually fits your workflow.
Here's what to take away:
The techniques in this lesson apply to every AI tool you'll use — chat interfaces, API calls, automated pipelines, and embedded AI features in tools like Excel and Power BI. If you're working with AI in reporting workflows, the article on Automating Repetitive Reporting Workflows with AI: From Data Summaries to Stakeholder-Ready Narratives shows these format skills in action at scale.
For situations where you need machine-readable output for downstream systems — JSON, CSV, structured data — the next level of this skill is covered in Structured Output and JSON Mode: How to Force AI to Return Machine-Readable Data for Downstream Automation.
And if you're finding that your prompts still aren't landing quite right even after specifying format, the diagnostic framework in From Vague to Precise: How to Diagnose and Fix Prompts That Return Unhelpful AI Responses will help you trace exactly where the breakdown is happening.
Format is one of the fastest levers you have for improving AI output quality. Use it every time.
Intro to AI & Prompt Engineering