Chidi manages a small import and distribution business in Atlanta, twelve employees, about 200 active SKUs, clients across three states. He started using AI to help with supplier communication and found it genuinely useful. But when he tried to use it for something his operations manager actually needed, a weekly inventory status report that could be pasted directly into their logistics software, the AI kept giving him paragraphs of text. "Here is a summary of your inventory situation: You have approximately 40 units of product A remaining..." His operations manager had to manually reformat every output before it was usable. At that point, the AI was creating more work, not less. The problem was not what the AI knew. It was how the AI was presenting it. And that was entirely within Chidi's control to fix.

Format Is Not Decoration

When AI gives you an answer in the wrong format, you have to reformat it before you can use it. That reformatting costs time. For a one-off question, that is minor. For a recurring task that feeds into your software, your spreadsheet, or a report you share with clients, reformatting every output is a tax on every use of AI in your workflow. It is also the kind of cost that never appears on an invoice, so it tends to survive uninspected for months.

AI will output whatever format you ask for. Most people never ask. They write a prompt, get a response, and work around the format. The fix is simple: tell the AI exactly how you want the output structured, before it gives you the output. Format instructions are not a separate skill to learn on top of prompting. They are one more sentence in the prompt you were already writing.

Think of it like ordering food at a deli counter. If you walk up and say "I'd like some turkey," you will get turkey in whatever cut and portion the person behind the counter defaults to. If you say "I'd like six ounces of sliced turkey, thin sliced, in a paper wrap," you get exactly what you need with no extra steps. The AI is the person behind the counter. The format instruction is the specifics of your order.

The Formats You Will Actually Use

Five formats cover nearly everything a small business asks AI to produce. Each one has a shape the next system in your workflow expects, whether that next system is a human reading an email, a spreadsheet, or an automation step. Choosing the format is really choosing who or what reads the output next.

Plain text

Good for: emails, letters, social media posts, anything a human will read and send as-is. The default. No special instructions needed unless the AI adds formatting you do not want, such as bullet points in what should be a flowing email. That specific failure is common enough to be worth a standing instruction, because a client email broken into bullets reads as a memo rather than a message from a person. Instruction example: "Write this as flowing paragraphs only. No bullet points, no headers, no lists."

Bullet lists

Good for: meeting agendas, to-do lists, feature comparisons, key points in a briefing. AI defaults to bullet lists readily. The issue is usually controlling depth, since it sometimes creates sub-bullets when you want one level. Nesting is where a list stops being scannable, and it is worth prohibiting explicitly rather than trimming afterwards. Instruction example: "Give me a flat bulleted list. No sub-bullets. Each point one sentence maximum."

Tables

Good for: comparing options, pricing tiers, task assignments, schedules. Tables are where AI output becomes genuinely powerful for business use. A well-structured table can paste directly into a client presentation or internal report. The instruction that matters most is naming the columns, in order, because an unnamed table gets whatever columns the AI thinks are interesting, which is rarely the set your spreadsheet is expecting. Instruction example: "Format the output as a table with four columns: Product Name, SKU, Current Stock Level, Reorder Point. Include one row per product. No summary paragraph."

JSON

JSON (JavaScript Object Notation) is a structured data format used by software systems. If you are feeding AI output into an app, a spreadsheet formula, or a no-code automation tool like Zapier or Make, JSON lets the next system read the data without parsing text.

You do not need to know how to code to use JSON output. You just need to know when to ask for it and what fields to specify. The field names are the whole contract: whatever you write in the prompt is what the receiving system will look for, so spell them exactly as the destination expects, including the underscores and the lowercase. Instruction example: "Return the results as JSON. Each item should have these fields: sku, product_name, quantity_on_hand, reorder_threshold. Return an array of objects."

Chidi used this format to connect his AI output directly to his logistics software via a Zapier step. The step reads the JSON, maps each field, and creates the inventory record automatically. No reformatting, no copy-paste. The phrase "return an array of objects" is doing real work in that instruction: it tells the AI to produce a list of records rather than one merged blob, which is what the mapping step needs to iterate over.

The underscores in sku, product_name, quantity_on_hand and reorder_threshold are not a style choice either. Field names are matched literally by whatever reads them, so quantity_on_hand and "Quantity On Hand" are two different fields as far as the receiving system is concerned, and one of them maps to nothing. Before you write the prompt, find out what the destination actually calls each value and copy those strings exactly. That single habit prevents most of the mysterious empty-record failures people hit on their first automation.

Numbered lists for step-by-step instructions

Good for: training documentation, SOPs (standard operating procedures), anything where sequence matters. Numbered lists communicate that steps must be followed in order. Starting each step with a verb is a small constraint with a large effect, because it forces the AI to write an action rather than a description of an action. Instruction example: "Write this as numbered steps. Each step should start with a verb. Maximum twelve steps. Each step one to two sentences."

Headers and sections

Good for: reports, proposals, documents you will share with clients or employees. Asking for explicit section headers makes long AI outputs navigable and professional-looking. Naming the headers yourself also fixes the order, which matters when the document is one a client sees repeatedly and expects to find the same things in the same places. Instruction example: "Organize the response with these section headers: Overview, Key Findings, Recommended Actions, Next Steps. Each section should be three to five sentences. No conclusion section."

Matching the Format to the Destination

Notice that the exclusions matter as much as the inclusions. "No summary paragraph" and "no sub-bullets" are not stylistic preferences; they are the difference between output you paste and output you edit. AI tends to add a friendly wrapper around structured content, and that wrapper is exactly what breaks a paste into a spreadsheet or an automation step.

The Full Format Instruction Template

For recurring tasks that always need the same format, write the format instruction once and reuse it. Here is a template structure:

"[Task description]. Format your response as [format type]. Include [specific fields or sections]. Do not include [things to exclude]. Keep total length [word or character count, or line count]. Tone: [professional/casual/technical]."

Every bracket in that template is a slot you fill for your own task. The order is deliberate as well. The task comes first so the AI knows what it is doing, the format comes next so it knows what shape the answer takes, and the exclusions and limits come last so they apply to everything above them.

Here is Chidi's weekly inventory report written out in full: "Review the following inventory data and identify items below reorder threshold. Format your response as a table with columns: SKU, Product Name, Current Qty, Reorder Point, Status (OK/REORDER/CRITICAL). Sort by Status with CRITICAL at the top. Do not include narrative text or a summary. Include only items where Current Qty is below Reorder Point."

That instruction produces a table his operations manager can use in thirty seconds. Without it, he got paragraphs that took ten minutes to reformat. Look at what the instruction is actually doing beyond naming a format: it fixes the column set, it defines the allowed values in the Status column, it fixes the sort order, it bans narrative, and it filters the rows. Five decisions the operations manager would otherwise have made by hand, every week, forever.

That is the real reason to write the long version once rather than a short version every week. A recurring task is not one task; it is the same task repeated indefinitely, so every decision you leave unspecified is a decision somebody re-makes on every run. Specifying them in the prompt also makes the output consistent between runs, which matters as soon as more than one person touches the report, because two people filling the same gaps by judgment will fill them differently and nobody will know which week is the anomaly.

Testing Format Instructions

When you introduce a new format instruction, test it three times with different inputs before relying on it in a real workflow. AI will occasionally interpret format instructions differently than you intend, especially for complex tables or nested structures. Adjust the instruction until the format is consistent across all three tests. Then save that tested prompt as your template.

Use genuinely different inputs for the three runs rather than the same data three times. A short week and a long week, a clean data set and a messy one. Most format instructions hold up fine on the example you wrote them against and drift on the edge cases, so the edge cases are the ones worth spending a test on. Watch specifically for reappearing summary paragraphs, renamed columns, and rows the filter should have excluded.

When a test fails, fix the instruction rather than the output. It is tempting to correct the one bad table by hand and carry on, but the instruction is what will run next week and the correction will not. Ask what in the wording allowed the wrong reading, and tighten that clause specifically: name the column that got renamed, restate the exclusion that got ignored, spell out the sort order that drifted. Then run the three tests again from the beginning, because a tightened instruction is a new instruction and has not been tested yet.

Anti-Patterns to Avoid

• Reformatting the output instead of fixing the prompt. The first time is faster to fix by hand. By the tenth time, you have paid more in cleanup than the format instruction would have cost to write once.
• Naming a format without naming its contents. "Give me a table" leaves the AI to choose columns. Name the columns, in order, or expect a different set each week.
• Leaving out the exclusions. Structured output that arrives wrapped in an introductory sentence and a closing summary cannot be pasted anywhere. "Do not include narrative text or a summary" is not rudeness, it is the load-bearing half of the instruction.
• Guessing at JSON field names. The receiving system looks for exact strings. If the destination expects quantity_on_hand, then quantityOnHand or "Quantity On Hand" will map to nothing.
• Trusting a new format instruction on its first success. One clean run tells you the instruction can work, not that it will. Three runs on different inputs is the standard before it goes into a workflow.
• Asking for JSON when a human is the reader. Format follows destination. Structured data pasted into a client email is as wrong as prose pasted into an automation step.

Practice Prompts

Run these against data you actually have. The point is to see the output land in its destination without editing.

• Find your reformatting tax. "Here is an AI output I receive regularly: [paste it]. Here is what I have to do to it before I can use it: [describe the edits]. Write me a single format instruction that would have produced the usable version directly."
• Column discipline. "Format the output as a table with four columns: Product Name, SKU, Current Stock Level, Reorder Point. Include one row per product. No summary paragraph. Here is the data: [paste]."
• JSON handoff. "Return the results as JSON. Each item should have these fields: [list the exact field names your destination expects]. Return an array of objects. Return nothing before or after the JSON."
• SOP conversion. "Turn the following process description into numbered steps. Each step should start with a verb. Maximum twelve steps. Each step one to two sentences. Here is the process: [paste]."
• Template fill. Take the full format instruction template above, fill every bracket for one recurring task in your business, and run it three times on different inputs before saving it.

Reflection Questions

• Which AI output in your week gets edited by hand every single time before anyone can use it?
• For that output, what is the destination: a person, a spreadsheet, or a piece of software? Does the format match?
• What does the AI keep adding that you keep deleting? Have you ever told it not to?
• Are your recurring format instructions saved somewhere, or rewritten from memory each time?
• Which of your formats has been tested on a messy input rather than a tidy one?

Glossary

• Format instruction: The part of a prompt that specifies the structure of the answer, including format type, fields or sections, exclusions, length, and tone.
• JSON (JavaScript Object Notation): A structured data format used by software systems, which lets a receiving app or automation read values by field name instead of parsing text.
• Array of objects: A JSON structure holding a list of records, each with the same named fields, so an automation can process the records one at a time.
• Field: A named slot in a structured record, such as sku or reorder_threshold. The name must match exactly what the receiving system expects.
• SOP (standard operating procedure): A documented, repeatable process, usually written as numbered steps because sequence matters.
• Exclusion clause: The "do not include" portion of a format instruction, which suppresses the narrative wrapper AI adds by default around structured output.

Related Lessons

• The Anatomy of an Effective Prompt places the format instruction among the other components a complete prompt needs.
• Prompt Templates for Daily Business Operations is where a tested format instruction belongs once it has survived three runs.
• Document Processing and Data Extraction with AI applies structured output to the reverse problem of pulling fields out of documents you receive.
• Integration Platforms: Zapier, Make, IFTTT for AI covers the automation step that consumes the JSON your prompt produces.
• Organizing Business Data for AI Consumption deals with the input side, since a clean format instruction still needs coherent data underneath it.

Closing

Chidi's inventory problem was never an intelligence problem. The AI understood his stock levels perfectly well the whole time; it just kept handing them over in a shape nobody could use. One instruction, naming the columns, the sort order, the filter, and the things to leave out, turned a weekly ten-minute cleanup into a paste. Nothing about the underlying capability changed.

Pick the AI output you edit most often this month and write its format instruction properly, brackets and all. Test it three times, save it, and stop paying the reformatting tax.

Key Takeaways

• AI outputs whatever format you ask for. If you do not specify, you get whatever the AI defaults to, usually paragraphs or bullet points.
• Reformatting AI output every time it is used is a hidden cost. Fix the format at the prompt level so the output is usable immediately.
• The five most useful formats for small business are: plain text, bullet lists, tables, JSON, and numbered steps. Each has specific use cases where it adds real value.
• JSON connects AI output to software systems without manual copy-paste. You do not need to code to use it, just specify the field names you need.
• Write a full format instruction for any recurring task. Specify the format type, fields, exclusions, length, and tone. Reuse it every time.
• Test any new format instruction three times before relying on it. Adjust until the output is consistent, then save the tested prompt as your template.
• Format instructions apply to sections too. Specifying headers, the order of sections, and whether to include a summary gives you structured documents that need no editing before sharing.

Frequently Asked Questions

• Do I need to know how to code to ask for JSON? No. You need to know when the destination is a piece of software rather than a person, and you need the exact field names that destination expects. The prompt does the rest.
• Why does the AI keep adding a summary paragraph I did not ask for? Because a friendly wrapper is its default around structured content. The remedy is an explicit exclusion, such as "Do not include narrative text or a summary," in the same instruction that names the format.
• How many times should I test a new format instruction? Three, using genuinely different inputs. Complex tables and nested structures are where interpretation drifts, so adjust until all three runs come out consistent, then save the tested version.
• What should a full format instruction contain? The task description, the format type, the specific fields or sections, the things to exclude, a length limit, and a tone. Missing any one of those is where hand editing creeps back in.
• Can one instruction cover both a table and a written summary? It can, but it is usually the wrong choice for a recurring workflow. Decide who reads the output next: if a system does, keep it purely structured and generate the human-readable version as a separate request.