AI Foundations for Small Business · Lesson 3 of 11
How to Prompt
Time: ~30 min reading + ~20 min worksheet Goal: Learn the handful of prompting patterns that do 90% of the real work. No "magic prompt" nonsense.
---
You've seen the articles: "The 50 ChatGPT prompts that will 10x your productivity!" They sell well because they feel like cheat codes. They're mostly nonsense.
The truth is simpler and more useful: there are maybe six prompting patterns that cover almost every business use case. Learn these, and you can write a prompt for any situation. Skip the "prompt libraries."
An LLM doesn't read your mind. It's a next-word predictor working off the input you give it. Garbage input = garbage output. Clear, specific, well-structured input = remarkable output.
The difference between a useless AI response and a great one is usually 60 seconds of effort on the prompt.
Every good business prompt has four parts. Call it the RCTO structure:
R — Role
Who should the AI pretend to be? > "You're an experienced operations manager at a 50-person manufacturing company..."
C — Context
What's the background, data, or situation? > "We're considering adding a second shift. Current headcount is 32, revenue is $6M, we've been at capacity for 8 months..."
T — Task
What specifically do you want it to do? > "Draft a one-page memo to the owner with the pros, cons, and a recommended next step."
O — Output format and constraints
How should the answer look? > "Use plain language, no jargon. Bullet points for pros/cons. Keep it under 400 words. Don't use phrases like 'in today's fast-paced world.'"
Not every prompt needs all four — a quick "what's the capital of Nebraska?" doesn't. But anything with business stakes should have most of them.
Pattern 1: The Structured Draft
Use for: Any time you're producing written content — emails, memos, proposals, scripts.
Template: ``` Role: You are [role with relevant expertise]. Context: [Situation, audience, purpose]. Task: Write [what, length]. Tone: [adjectives — e.g., warm, direct, professional, folksy]. Constraints: [things to avoid — jargon, buzzwords, length limits]. Output: [format — email, bullets, prose, etc.]. ```
Example: > You are an IT services account manager writing to a small medical practice client. They've had three helpdesk tickets this month about slow Outlook. We suspect it's an OST file issue, but we also want to proactively offer an assessment. Write a short email (under 150 words) that acknowledges the problem, explains we have a plan, and offers a no-cost 30-minute assessment. Tone: calm, competent, not salesy. No marketing buzzwords.
Pattern 2: The Critic / Editor
Use for: Improving something you've already drafted.
Template: ``` Here's a [thing I wrote]: [paste it].
Review it critically. Tell me:
- What's unclear or weak
- What assumptions it makes that the reader may not share
- What's missing
- How to make it [shorter/more direct/more persuasive]
Then rewrite it incorporating your suggestions. ```
This pattern is magic for email drafts, proposals, slide decks, even code. The "tell me what's wrong first, then rewrite" structure forces the model to actually think instead of just surface-editing.
Pattern 3: The Extractor
Use for: Pulling structure out of messy text.
Template: ``` From the text below, extract [the specific things you want] and return them as [JSON / a table / bullet list].
[Paste the text]
Only include items explicitly supported by the text. If something is unclear, say "unclear" rather than guessing. ```
This is the pattern behind most useful business automation. Customer emails, resumes, invoices, contracts, meeting notes — all of them turn into structured data with the Extractor pattern.
Pattern 4: The Expander
Use for: Going from bullet points or a sketch into full prose or a full document.
Template: ``` Here are the key points I want to cover: [your bullets or outline].
Audience: [who's reading]. Purpose: [what action you want them to take]. Desired length: [rough wordcount]. Tone: [adjectives].
Turn this into a [memo / email / article / deck outline]. ```
Expander is the workhorse for busy people. You think in bullets; AI turns them into prose. Then you edit.
Pattern 5: The Explainer
Use for: Understanding something new, or translating expert content for a different audience.
Template: ``` Explain [concept or document] to [audience — a 10-year-old, a CFO, a new employee, a doctor] in about [length].
Use [analogies / examples / plain English]. Avoid [jargon / technical depth]. Assume they know [what they already know] and don't know [what they don't]. ```
Explainer is unbeatable for onboarding, training, documentation, and — crucially for you — preparing to walk into client meetings in industries you don't know well.
Pattern 6: The Roleplay / Simulator
Use for: Practicing conversations, stress-testing ideas, rehearsing.
Template: ``` Act as [specific role — a skeptical CFO, a difficult customer, an auditor]. Your goal is to [what the persona wants]. You have these concerns: [list them].
I'm going to present [my pitch / my plan / my email]. Respond as this persona would, including any objections or questions.
[Your content] ```
Incredibly useful for rehearsing a pitch before a real meeting. Ask Claude to play a skeptical SMB owner — you'll find the weak points in your proposal in 5 minutes instead of in the meeting.
A few extra moves that pay off:
Chain of Thought
If you want the model to reason through something, ask it to "think step by step" or "work through this out loud before giving your answer." Especially useful for analysis, math, or decision-making.
Few-Shot Examples
If you want consistent output, show the model examples of what you want. One or two good examples will shape the output more than any amount of instructions.
> Here are three good subject lines for our newsletter: > - "The 30-second trick that cut our helpdesk tickets in half" > - "Microsoft just changed something. Your users will notice." > - "We're hiring. Here's who we want." > > Write five more in the same style.
Meta-Prompting
Ask the AI to help you write a better prompt. "What information would you need to do this task well?" or "Improve this prompt to get a better answer." It's allowed to coach you.
Break It Up
Don't ask an LLM to do three things in one shot if they're complex. Have it do step 1, review, then move to step 2. Context stays cleaner and quality goes up.
- Telling it to "take a deep breath" — was briefly a research finding; modern models don't need it.
- Threatening or bribing the model — doesn't work, makes you feel gross.
- Claiming to be an expert yourself ("As a senior consultant...") — fine but doesn't add much. State the task clearly instead.
- Over-engineered 1,000-word prompt templates — past a certain point you're adding noise. Aim for clarity.
When an AI gives you a bad answer, don't just retry. Diagnose:
- Was my instruction specific enough? Re-read your prompt. Did you say what you actually wanted?
- Did it have the information it needed? Did you give it the doc, the context, the data?
- Is this task hitting a known weakness? (Math, real-time info, counting specific things in long text.)
- Try a different model. Claude, ChatGPT, and Gemini fail at different things.
If the answer is still bad after two honest iterations, it might be a task that isn't ready for AI yet. That's also a useful finding.
When you're recommending AI for a client, the prompt quality problem becomes a *workflow design* problem. You're not just teaching them the tools — you're helping them build good prompts into templates, automations, and SOPs so their whole team gets consistent output.
This is where real value lives for SMBs:
- A one-page "prompt library" for the customer service team
- A Copilot/Claude template for their standard proposal structure
- A series of prompts in a Zapier workflow that processes incoming leads
- A custom GPT or Claude Project with their style guide and past examples built in
The prompts you write become *leverage*. One good prompt, used by 10 employees 100 times a month, is 1,000 units of value.
---
- RCTO — Role, Context, Task, Output. The backbone of a good business prompt.
- Six patterns cover most use cases: Structured Draft, Critic, Extractor, Expander, Explainer, Roleplay.
- Examples beat instructions when consistency matters.
- Diagnose failures — don't just retry.
- The real SMB value is building prompts into templates and workflows, not just typing in a chat window.
---
Next up: Module 4 — Beyond Chat. What happens when you connect AI to other systems, trigger it automatically, and let it take actions.
---
Time: ~20 min (hands-on) Goal: Practice each of the six patterns on real SMB-flavored tasks.
---
Here's a bad prompt:
> "write me a proposal for the hvac company"
Using RCTO, rewrite it into a prompt that would get a genuinely useful response. Make up reasonable context (client name, what they do, what you're proposing, etc.).
Your upgraded prompt:
```
```
Now run *both* (the original and your version) in ChatGPT or Claude. Compare the outputs.
Do each of these on an AI tool of your choice. You don't have to save the outputs — you just need to *do* them.
Pattern 1 — Structured Draft: Write a 120-word email announcing that your (imaginary) company is closing early next Friday for a team event. Audience is your customers.
Pattern 2 — Critic: Paste this mediocre email into Claude or ChatGPT and use the Critic pattern on it: > "Hi everyone, I wanted to reach out today to let you know that we have some exciting updates that I think you're going to really love. Over the past few months our team has been working incredibly hard to improve our service offering, and I'm thrilled to share some of what we've been up to..."
Pattern 3 — Extractor: Find any recent email in your inbox with a vendor quote. Use the Extractor pattern to pull out: vendor name, amount, payment terms, what's included, expiration date. Format as JSON.
Pattern 4 — Expander: Start with this outline and ask the AI to expand it into a 300-word blog post:
- AI is overhyped in some ways
- But also underhyped in others — SMBs really are leaving money on the table
- Three specific use cases that are ready today
- Start small, measure, iterate
Pattern 5 — Explainer: Ask the AI to explain "RAG (retrieval-augmented generation)" to a 55-year-old SMB owner who's not technical. Two paragraphs max.
Pattern 6 — Roleplay: Tell the AI to act as a skeptical, cost-conscious 60-person distributor owner. Pitch them on "adding AI to your customer service." See what objections come up.
Note anything that surprised you: ______________
Pick a task you (or someone you know) does regularly — like writing a weekly status update, responding to common customer questions, drafting onboarding emails for new hires. Build a *reusable* prompt for it:
- Use RCTO structure
- Add 1–2 few-shot examples
- Include the specific constraints that make your organization sound like you
- Be explicit about what *not* to do (avoided words, banned phrases, etc.)
Your reusable prompt:
```
```
Test it twice with different inputs. Does it produce consistent output?
---
Exercise 1: Your rewritten prompt should probably be 100–300 words itself. If it's still one sentence, you haven't used RCTO.
Exercise 2: The six patterns should feel different from each other. The Critic pattern in particular is often the one people haven't seen before — it's one of the highest-leverage moves in everyday AI use.
Exercise 3: This is the pattern that turns AI from a toy into business infrastructure. When you have 10 reusable prompts that your team actually uses, you've extracted real value. This is also the deliverable pattern to build for clients.
---
Check yourself: If someone asked you "how do I write a good prompt?" — could you teach them RCTO and name the six patterns from memory? That's the bar before Module 4.
Previous: The AI Tool Landscape · Next: Beyond Chat: Agents, Automations, and APIs