The sequence in this article does the opposite. You give AI a controversial idea, then run it through four deliberate phases: build the best case for it, challenge that case hard, destroy it completely, then rebuild something more honest from the wreckage. By the end, you don’t have the same opinion you started with. You have a better one, or at least a more defensible one.

I’m going to use a real example throughout: “you don’t need an email list anymore.” It’s a claim that gets recycled every 18 months by someone who found a new channel. Running it through this sequence produces something more interesting than either “yes you do” or “no you don’t.”

Get to Prompt 1 by the end of this paragraph. You’ll run all five in a single session, ideally on an idea you’re genuinely uncertain about. The more you care about being right, the more useful this gets.

Prompt 1: Build the strongest case

What it does: Forces AI to construct the most credible, well-supported argument FOR the controversial idea, without hedging or balancing.

When to use it: At the start of the sequence. Don’t let AI hedge. If it adds “on the other hand” anywhere, reject the output and run it again.

The prompt:

I want you to make the strongest possible case for this claim: [YOUR CONTROVERSIAL IDEA]

Rules:
- Argue only FOR the claim. Do not hedge, balance, or acknowledge counterarguments.
- Use specific examples, real numbers, or named sources where possible. No vague attribution like "experts say."
- Write 3-4 paragraphs. Each paragraph should make a distinct point, not repeat the same point with different wording.
- Audience: solopreneurs selling digital products
- If you find yourself writing "while it's true that..." or "of course, there are nuances," stop and delete that sentence.

Claim: [YOUR CONTROVERSIAL IDEA]

How to use it:

1. Drop in your controversial idea. Be specific: “you don’t need an email list anymore” is better than “email lists are overrated.”

2. If the output hedges, paste it back with the instruction: “You hedged in paragraph 2. Rewrite it without the qualification.”

3. Save the output. This is your “build” document.

Example input: Claim: You don’t need an email list anymore. Social platforms, community tools and direct messaging have made email lists an outdated default for solopreneurs selling digital products.

What you’ll get: 3-4 paragraphs making a confident, specific case for the claim. It’ll be more persuasive than you expect, which is the point.

Advanced note: The quality of the build argument determines how useful the rest of the sequence is. A weak build produces weak challenges. If the output feels thin, ask AI to add “one more specific example from the last two years” until it has real teeth.

You just got the build. One prompt, one confident argument, no hedging.

The problem is you still don’t know if it holds up. Anyone can build a case for anything. The next four prompts do the harder work:

• Challenge the argument on its weakest points

• Find the conditions where it completely falls apart

• Destroy it with the strongest counterargument possible

• Rebuild something more honest from what survives

Plus: a bonus template for running this sequence on any idea in any niche.

Upgrade to get the complete system.

Read more

The model got the logic right. It got the facts right. And somehow the result is completely forgettable.

I’ve been thinking about why that happens, and I don’t think the answer is that the models are bad. I think the answer is that we’re prompting for the wrong thing.

We optimized for correctness and got boredom

The first wave of prompt engineering was about getting AI to stop making things up. Reduce hallucinations. Improve accuracy. Get the model to cite sources, follow instructions, stay on topic. All reasonable goals, and we mostly got there.

The second wave was about consistency. Chain-of-thought prompting, structured outputs, system prompts that constrain behavior. Again, reasonable. Again, mostly achieved.

What nobody talked about much during either wave was texture. The quality of the prose. Whether the output felt like it came from a specific sensibility or from a statistical average of every sensibility. Whether reading it produced any feeling at all.

I think that’s the gap we’re in now. Most frontier models can perform logic. They can follow instructions with a precision that would have seemed remarkable two years ago. The question that’s getting more interesting is what happens after correctness. What happens when you stop prompting for accuracy and start prompting for character.

The problem with “smart”

Smart AI outputs have a tell. They’re thorough. They cover the counterarguments. They use words like “while it’s true that” and “it’s worth noting” and they end with a balanced summary that lands nowhere in particular. They are the written equivalent of a consultant who never gives you a straight answer because they don’t want to be wrong.

The reason this happens isn’t a model failure. It’s a prompting failure. When you prompt for correctness, you get correctness. The model is doing exactly what you asked. You just didn’t ask for the thing that makes writing worth reading.

A few months ago I started experimenting with what I’d call intentionally flawed prompting. Not asking the model to make mistakes exactly, but asking it to have a point of view strong enough that it might be wrong. To write with a voice that has friction in it. To make aesthetic choices that a different writer would have made differently.

The results were different enough that I kept doing it.

Latent space, briefly explained

There’s a technical concept worth knowing here, even if you don’t care about the technical details.

When a language model processes text, it’s working in what researchers call latent space: a high-dimensional mathematical space where similar concepts cluster together. “Dog” and “cat” are close. “Dog” and “democracy” are far apart. Every word, sentence and piece of writing you’ve ever encountered has a position in this space.

When you write a prompt, you’re not just giving the model instructions. You’re pointing it toward a region of latent space. A bland, neutral prompt points toward the center of that space, toward the most average, statistically typical version of whatever you asked for. A strange, specific, textured prompt points toward the edges, toward combinations that are less common and therefore less expected.

Most prompt engineering advice is about getting to the right neighborhood. What I’m arguing is that inside each neighborhood, there’s a distribution of outputs ranging from generic to genuinely interesting, and the difference between them isn’t accuracy. It’s the aesthetic coordinates of your prompt.

What vibe curation actually means in practice

I want to be careful here not to make this sound more mystical than it is. Prompting for texture is a learnable skill with concrete techniques. The strangeness is in the output, not the method.

In practice it looks like this: instead of asking AI to “write an email announcing a price increase,” you ask it to write the email “in the voice of someone who respects their customers enough to be direct rather than diplomatic, and who finds corporate softening language slightly embarrassing.” Instead of asking for “a persuasive argument,” you ask for “an argument that sounds like it was written by someone who has lost this argument before and learned something from it.”

You’re specifying a sensibility, a mind behind the piece. You’re telling the model what kind of person would write this and what choices that person would make and refuse to make.

This is why I think the frame of “prompt engineering” is starting to feel dated. Engineering implies optimization toward a correct answer. What’s happening now is closer to curation. You’re not solving for the right output. You’re selecting from a distribution of possible outputs by shaping the aesthetic conditions that generate them.

A useful analogy: a film director and a cinematographer working together aren’t engineering a scene. They’re making thousands of small aesthetic decisions, each one narrowing the possibility space until what’s left is something with a specific feeling. The script might say “two people argue in a kitchen.” Everything else is curation.

Why this matters more for solopreneurs than anyone else

Enterprise AI use is mostly about throughput. Volume of emails processed, documents summarized, support tickets resolved. At that scale, correctness and consistency are genuinely what matter. You don’t want your customer service AI having a distinctive voice. You want it to handle volume without errors.

Solopreneurs selling digital products are in a completely different situation. Your outputs are your brand. The way your emails sound, the texture of your sales copy, the specific sensibility that runs through your content: that’s what people are actually buying when they buy from you. They can get generic information anywhere. They buy from you because of how you think.

Which means that if you’re using AI to produce generic-sounding content, you’re actively undermining the thing that differentiates you. And most AI-generated content for solopreneurs is generic-sounding, because most people are prompting for correctness rather than character.

The vibe-check economy is the term I’ve been using internally for the shift that follows. Audiences are getting better at detecting AI-generated content not because it’s factually wrong but because it has no texture. No friction. No evidence of a specific person having made specific choices. The response to that, if you’re smart about it, is to use AI differently rather than use it less.

That’s the argument. Here’s how to actually act on it.

The next section is 9 prompts built specifically around vibe curation: techniques for prompting with sensibility instead of just instructions, including how to specify aesthetic coordinates, how to introduce productive friction, how to get AI to make choices a human editor would recognize as choices, and how to test whether your output has texture or just correctness.

Plus: a reference sheet of 15 aesthetic modifiers you can drop into any prompt to shift its output away from the statistical center.

Upgrade to get the complete toolkit.

9 prompts for vibe curation

A quick note on how these work: these aren’t independent prompts you run separately. They’re techniques, each with a specific use case. Some you’ll use at the start of a session, some mid-draft, some as a check on output you’re not sure about. Run them in the order that fits your workflow.

Prompt 1: The sensibility spec

What it does: Specifies the aesthetic sensibility behind a piece of writing, separate from its topic or format.

When to use it: Before any writing task where voice matters. This replaces or supplements your usual system prompt.

Read more

AI can cut that process down to a few hours. Not because it writes perfect copy (it doesn’t), but because it handles the structural thinking that usually paralyzes people. The audience diagnosis. The objection map. The offer framing. All the stuff you’d normally stare at a blank doc trying to figure out.

These 9 prompts build a complete mini funnel for a digital product: opt-in page, welcome sequence, sales page, and checkout copy. Each one picks up where the last left off. Run them in sequence, and you’ll have a working draft by end of day.

I want to be upfront about something before you start: AI-generated funnel copy needs editing. The prompts here are structured to minimize how much, but your voice, your specific proof, your real numbers still have to go in. Think of this as a fast scaffold, not a finished building.

Prompt 1: Audience pain diagnosis

What it does: Produces a detailed profile of your buyer’s core frustrations, so your funnel speaks to what they’re actually feeling, not what you assume they feel.

When to use it: Before writing a single word of copy. This output feeds every other prompt in the sequence.

The prompt:

You're helping me build a sales funnel for a digital product. Before I write any copy, I need a clear picture of my buyer.

My product: [PRODUCT NAME AND ONE-SENTENCE DESCRIPTION]
Who buys it: [TARGET BUYER, e.g. "freelance designers who want to raise their rates"]

Give me:
1. The 4-5 specific frustrations this person has BEFORE they find my product. Be specific, not generic. "I waste 3 hours every client call explaining my pricing" is specific. "They struggle with pricing" is not.
2. The 3 things they've probably already tried that haven't worked
3. What they're secretly afraid to admit is the real problem
4. The result they want in plain language (not the product features they'd buy, but the life outcome they're after)

Write this as a clear bulleted profile, not a paragraph. I'll use this to write my opt-in page, emails, and sales page.

How to use it:

1. Fill in your product and buyer description. Be specific, even if it feels over-narrow.

2. Read the output and flag any frustrations that feel off. Edit them or ask AI to revise.

3. Save this profile. You’ll paste it into the next 4 prompts.

Example input: My product: “The Rate Raise Toolkit, a Notion template system for freelance designers to document and present their value so they can charge premium prices.” Who buys it: freelance graphic designers who’ve been charging the same rates for 2+ years and feel stuck

What you’ll get: A buyer profile with specific language you can pull directly into your copy. If the frustrations sound generic, push back and ask for more specificity.

Advanced note: The “secret fear” section is the most useful output here. Buyers rarely say “I’m afraid I’m not worth more money” out loud, but they feel it. Copy that addresses that fear converts better than copy that just lists features.

Prompt 2: Opt-in page copy

What it does: Writes a complete opt-in page including headline, subheadline, bullet points and a CTA, using the pain profile from Prompt 1.

When to use it: After you’ve confirmed the buyer profile from Prompt 1 looks accurate.

The prompt:

Using the buyer profile below, write opt-in page copy for a free lead magnet that gets people into my funnel.

Buyer profile: [PASTE OUTPUT FROM PROMPT 1]

Lead magnet: [LEAD MAGNET NAME AND FORMAT, e.g. "a free 5-page PDF called 'The Rate Audit' that helps designers calculate exactly what they should be charging"]

Write:
- A headline (under 12 words) that names the specific outcome
- A subheadline (1-2 sentences) that adds context and addresses the main fear
- 4-5 bullet points that describe what they'll get (use "so you can" after each benefit to tie it to an outcome, not just a feature)
- A CTA button label (3-6 words, not "Submit" or "Download Now")

Tone: direct and slightly skeptical, like someone who's been burned by useless free resources before but this one is different

How to use it:

1. Paste the full buyer profile from Prompt 1.

2. Describe your lead magnet in one sentence.

3. Take the headline output and write 3 variations. Pick the one that makes you slightly uncomfortable because it’s too direct.

Example input: Lead magnet: a free checklist called “The 5 Questions Every Design Client Should Answer Before Getting a Quote” -- positions designers as experts upfront

What you’ll get: A complete opt-in page draft. The bullets usually need tightening but the structure is solid.

Advanced note: The CTA label matters more than most people think. “Get the checklist” outperforms “Download now” because it’s specific. Ask AI to write 6 CTA options and pick your favorite.

Prompt 3: Welcome email sequence

What it does: Writes a 3-email welcome sequence that warms up new subscribers before any sales pitch appears.

When to use it: After your opt-in page copy is done. These emails go out automatically when someone signs up.

The prompt:

Write a 3-email welcome sequence for new subscribers who just downloaded my lead magnet.

Product I'm eventually selling: [PRODUCT NAME AND PRICE]
Lead magnet they downloaded: [LEAD MAGNET NAME]
Buyer profile: [PASTE OUTPUT FROM PROMPT 1]

Email 1 (sent immediately): Deliver the lead magnet, set expectations for what's coming, make one observation about why most people in this situation stay stuck. No pitch. End with a question they can reply to.

Email 2 (sent day 2): Share a specific, short story or example about someone who had this problem and what changed for them. Not a testimonial. A real narrative with a before and after. End by teasing that the next email goes deeper.

Email 3 (sent day 4): Introduce the paid product. Don't hard sell. Explain what it is, who it's for, and link to the sales page. One paragraph max on the product itself.

Tone across all 3: like a knowledgeable peer who's been where they are, not a marketer who wants their money
Subject line for each email: specific and curiosity-driven, not clickbait

How to use it:

1. Fill in product, lead magnet and buyer profile.

2. For Email 2, add a real story from your own experience or a client’s. The AI version will be a placeholder.

3. Load these into your email platform as an automated sequence before you launch.

Example input: Product: Rate Raise Toolkit, $97 Lead magnet: The 5 Questions checklist

What you’ll get: Three ready-to-edit emails with subject lines. Email 2 will need the most work because it requires real specifics you’ll have to add.

Advanced note: Email 1’s reply question isn’t just for engagement. Real replies from subscribers tell you exactly what language to use in your sales page copy. Read them.

Three prompts in, you’ve got the easy half done.

The buyer profile, opt-in page and welcome sequence are where most guides stop. They’re also the part that doesn’t require you to ask anyone for money.

The sales page is different. It has to make an argument, handle doubt and get someone to type in their card details. That’s three separate jobs and most sales pages fail at all three.

The next 6 prompts break each one down:

1. a full page structure with headlines and offer stack,

2. an objection section built around the specific fears your buyer has,

3. checkout copy that doesn’t feel like a trap,

4. and a post-purchase confirmation that makes them feel good about the decision they just made.

5. The swipe file has 30 CTAs and urgency lines ready to use.

That’s the half that pays.

Read more

Those are different problems. And finding the second kind takes more than a survey or a guess.

AI is genuinely good at this, if you know how to ask. The prompts below go past surface-level frustrations into the specific, embarrassing, expensive problems your audience is sitting with. Work through them in order. By the end, you’ll have raw material for copy that feels like you read your customer’s journal.

Start with what your audience is already saying

Prompt 1: The complaint mining prompt

What it does: Pulls real language from the kinds of public complaints your audience posts online, organized by urgency and emotion.

When to use it: Before you write a single word of copy, to get the actual vocabulary your audience uses.

The prompt:

Act as a customer research analyst. My target audience is [DESCRIBE YOUR AUDIENCE - e.g., "solo consultants who sell $5k-$15k coaching packages"]. They are trying to [MAIN GOAL - e.g., "consistently fill their client pipeline"].

Imagine you've read 200 Reddit threads, forum posts and Facebook group discussions where this audience vents about their frustrations.

Give me:
1. The 5 most common complaints, written in their exact words (not cleaned up)
2. The 3 complaints they seem most ashamed of (the ones they lower their voice to say)
3. The 2 complaints they've basically given up on fixing

For each one, tell me: what they blame (themselves, a tool, the market, timing)?

How to use it:

1. Fill in your audience and their main goal as specifically as you can

2. Run it and read the shame-based complaints first. Those are almost always the ones that convert

3. Highlight any phrase that sounds like something you’d actually say out loud

Example input: Audience: “e-commerce store owners doing $10k-$50k/month.” Main goal: “get profitable without burning out on ads.”

What you’ll get: A list of complaints sorted by emotional charge, with insight into who (or what) your audience blames for their situation.

One note: The shame-based complaints are where the best copy lives. Most people avoid writing to those because it feels uncomfortable. That discomfort is a signal you’re onto something.

Prompt 2: The gap between “said” and “meant” prompt

What it does: Translates polite, sanitized customer language into what they’re actually feeling.

When to use it: After you’ve collected survey data, testimonials or customer interviews that sound generic.

The prompt:

I'm going to give you some feedback I've collected from my customers. Your job is to translate each piece from "polite customer speak" into the raw, honest version of what they probably meant.

For each one:
- Write the sanitized version (what they said)
- Write the honest version (what they likely meant, including the frustration they held back)
- Identify the specific fear or loss underneath the complaint

My customer feedback:
[PASTE 5-10 PIECES OF FEEDBACK, TESTIMONIALS OR SURVEY RESPONSES]

How to use it:

1. Paste in feedback you’ve actually collected, even if it seems positive

2. Pay attention to the “specific fear or loss” column, that’s your copy angle

3. If the honest version surprises you, you’ve been writing to the wrong problem

Example input: Feedback: “I just wish the process was a bit more straightforward.” / “It took longer than I expected to see results.”

What you’ll get: A side-by-side breakdown of what customers said vs what they were actually frustrated by, with the underlying fear named directly.

One note: Positive feedback often hides complaints. “It took longer than expected” almost always means “I was embarrassed to admit it wasn’t working.”

Prompt 3: The before-state excavation prompt

What it does: Maps the emotional and practical state your customer is in right before they go looking for a solution like yours.

When to use it: When your copy talks about features or outcomes but doesn’t capture the desperation (or exhaustion) that gets people to buy.

The prompt:

My product/service is [DESCRIBE WHAT YOU SELL].
My customer is [DESCRIBE WHO BUYS IT].

Describe in detail what the 24 hours before they purchase looks like. I want:

1. What they're physically doing (the specific task that's frustrating them)
2. What they're telling themselves (the internal dialogue, including the self-criticism)
3. What they've already tried (and why it didn't work)
4. The moment they decide to search for a solution - what triggers it
5. What they're afraid will happen if they don't fix this soon

Write this as a narrative, not a list.

How to use it:

1. Read the output and mark any sentence that describes your customer specifically (not just anyone with this type of problem)

2. Lift those specific phrases directly into your copy

3. The trigger moment in #4 is often your best ad hook

Example input: Product: “A project management template for freelance designers.” Customer: “Freelancers who are juggling 4-6 clients and missing deadlines.”

What you’ll get: A detailed narrative of your customer’s worst day, written in a way that’s directly usable in copy.

One note: If the narrative feels generic, add more specifics about your customer. The more constrained the prompt, the more useful the output.

You just got 3 prompts that go past surface complaints into the actual emotional state driving your customer’s decisions.

But knowing the problem is only half the work. The next 5 prompts handle turning that raw intelligence into copy angles:

• Finding the exact words that trigger recognition (”that’s me”)

• Writing the before/after contrast without sounding like an infomercial

• Surfacing objections before your customer raises them

• Plus: a ready-to-use customer voice capture template

Upgrade to get the complete system.

Turn insight into copy that sticks

Prompt 4: The “that’s exactly me” phrase finder

What it does: Generates hyper-specific phrases your audience uses to describe themselves and their situation, the kind that make readers think you’re in their head.

When to use it: When writing headlines, email subject lines or the opening line of a sales page.

The prompt:

Read more

People who spend serious time with AI prompting get a version of the same question eventually: how much of what you publish is actually you?

It’s a fair question, and I’d rather answer it directly than let the ambiguity sit.

I use AI tools every day. For research, for drafts, for working out whether a prompt structure is doing what I think it’s doing. If you’re writing seriously about how these systems respond to language, actually using them isn’t optional. Distance would make the writing worse.

But there are things I won’t let AI do on my behalf, and I think the prompting community, more than most, understands why that distinction matters.

People who work closely with these models know how good they are at producing confident, fluent output on almost any topic. They also know how often that output is wrong, averaged, or missing the specific judgment that comes from a real person with a real position.

I wrote my own AI manifesto because I wanted a clear account of where I stand, in writing, that I can be held to. What I’ll use AI for, what I won’t, and why the line sits where it does. It’s a short document, only

Download it here…

An Honest AI Manifesto

This is one manifesto. Written by one person, from one set of experiences with these tools. If reading this has made you think about where your own lines sit, that’s worth more than agreeing with mine.

So write it down. Not for an audience, not as a public statement, just for yourself. What you’ll do. What you won’t. Why the line sits where it does.

DISCLAIMER

The information is intended to be helpful, but is in no way a substitute for seeking professional advice for your specific situation or intent. This applies to business, financial, legal, health, medical, personal, or other matters discussed herein. Please read the full DISCLAIMER

Copyright Notice

The information in this document is protected by international copyright laws. You may use the information for personal purposes, but you are not permitted to duplicate it or distribute it to anyone else. This copy is for you only.

That’s fine. But there’s a different use case that barely gets talked about, and it’s arguably more valuable for anyone trying to build something or figure out where they’re headed. Using AI as a thinking partner. Not to produce output, but to think better.

I want to be honest about both sides of this, because the way it gets discussed online is usually either breathless enthusiasm or flat dismissal. The truth is messier. AI is genuinely useful for certain kinds of self-reflection and genuinely useless for others, and the difference matters if you’re going to spend time on it.

What “thinking partner” actually means

A thinking partner isn’t someone who agrees with you. A good one pushes back, asks questions you haven’t asked yourself, and helps you see the assumptions baked into how you’ve framed a problem.

Most people don’t have one. Your friends are too close to your situation. Your colleagues have their own agenda. Coaches are expensive. Therapists are focused on something different, though there’s overlap.

AI fills an odd gap here. It has no stake in your decisions. It won’t feel awkward if you say something embarrassing. It doesn’t get tired of the same problem coming up for the third week in a row. And if you ask it the right questions, it will tell you things that are genuinely uncomfortable to hear.

That last part is conditional on how you prompt it, which is what the rest of this is about.

What you’ll get

The first 3 prompts are for the hard stuff: auditing your assumptions, naming what you’re actually afraid of, and getting perspective from outside your current mental model.

The next 5 prompts go deeper:

• Mapping the gap between who you are and who you’re trying to become

• Using AI to stress-test a decision before you commit to it

• Finding the pattern in problems that keep coming back

• Getting honest feedback on your own blind spots

• Plus: a repeatable weekly reflection template

Prompt 1: The assumption audit

What it does: Surfaces the beliefs you’re treating as facts, specifically in a decision you’re currently stuck on.

When to use it: When you’ve been going in circles on something and can’t figure out why you’re not moving forward.

Read more

This article is a technical tutorial. You’ll learn how to take any website or app you admire, feed it to Claude, and extract the design system, layout logic, component structure and copy patterns behind it. Not vague inspiration. Actual reusable output.

Ten prompts. Real examples. You’ll have the first one done before you finish reading the setup.

What “replication” actually means here

This isn’t about copying someone’s code or lifting their assets. It’s about reverse-engineering the decisions behind a design: the spacing system, the typographic hierarchy, the colour logic, the way they handle empty states and CTAs.

Those decisions are learnable. And once you’ve learned them from a site you admire, you can apply them to something entirely your own.

Claude can’t browse live websites on its own, so the workflow here uses screenshots, copied HTML, and your own observations as the raw material. Each prompt below explains exactly what to feed in.

Prompt #1: Visual audit from a screenshot

What it does: Takes a screenshot of any page and extracts the full design system behind it: colours, type scale, spacing, layout grid and visual hierarchy.

When to use it: Start every replication project here. This is your reconnaissance pass.

The prompt:

I'm going to share a screenshot of a website or app screen. Analyse it as a senior
UI designer reverse-engineering someone else's work.

Extract and document the following:

1. Colour system: primary, secondary, accent, background and text colours.
   Give hex values where you can estimate them. Note any gradients.

2. Typography: identify heading sizes relative to each other, body text size,
   font weight usage, line height feel (tight/normal/loose) and any obvious
   font personality (geometric sans, humanist, serif, etc.)

3. Spacing system: what increment does the spacing appear to be based on?
   (4px, 8px, 12px?) Estimate padding inside components and margins between them.

4. Layout grid: how many columns? Is there a max-width container? How wide
   are the gutters?

5. Visual hierarchy: what does the eye go to first, second, third? What
   techniques create that order (size, colour, weight, whitespace, position)?

6. Component inventory: list every distinct UI component visible in the screenshot.

Screenshot: [PASTE OR ATTACH SCREENSHOT]

How to use it:

1. Take a full-page screenshot of the site or app screen you want to study

2. Paste it directly into Claude or attach it as an image

3. Save the output as your “design brief” for everything that follows

Example input: Screenshot of Stripe’s homepage hero section.

What you’ll get: A structured breakdown covering Stripe’s near-black backgrounds, the specific purple accent logic, the 8px spacing increment, the two-column split layout with a max-width around 1100px, and a component list including nav, hero headline block, code preview card and gradient mesh background.

Advanced note: Run this on three pages of the same site (homepage, pricing, docs) and ask Claude to identify which design decisions are consistent across all three. That consistency is the actual design system. The variations are the exceptions.

Prompt #2: CSS variable extraction from HTML

What it does: Takes pasted HTML/CSS source and extracts a clean, usable set of CSS custom properties that capture the design token layer of any site.

When to use it: When you want actual code output, not just observations. Use right-click > Inspect > copy the relevant CSS from a site you’re studying.

The prompt:

I'm going to paste HTML and CSS from a website I'm studying. Your job is to extract
and reconstruct the design token layer as CSS custom properties I can drop into my
own project.

Output a clean :root { } block containing:

- All colour values as --color-[name] variables
- Font family, size scale and weight as --font-[property] variables
- Spacing scale as --space-[size] variables (--space-1 through --space-10 or similar)
- Border radius values as --radius-[name] variables
- Shadow values as --shadow-[name] variables
- Any transition/animation timing values as --transition-[name] variables

Where the source uses hardcoded values instead of variables, infer the likely token
from the pattern. Name everything consistently.

After the :root block, write a one-paragraph summary of what kind of design system
this appears to be (e.g. "minimal 8px grid system with a monochromatic dark palette
and a single accent colour").

Here is the HTML/CSS:
[PASTE SOURCE CODE]

How to use it:

1. Open browser DevTools on the site you’re studying (F12 or right-click > Inspect)

2. Go to the Elements tab, find the <head> or a key component, copy the relevant CSS

3. Paste into Claude with this prompt

4. Drop the output --variables directly into your own project’s stylesheet

Example input: CSS from Linear’s app interface, including their component styles.

What you’ll get: A complete :root block with tokens like --color-surface-primary, --space-4: 16px, --radius-md: 8px and --shadow-card: 0 1px 3px rgba(0,0,0,0.12), plus a summary identifying it as a compact 4px-base grid with a near-black surface palette and tightly controlled border radius consistency.

Advanced note: Paste the token output back in and ask Claude to generate a Tailwind config object from it. You get a custom Tailwind theme calibrated to the design system you just extracted, ready to paste into tailwind.config.js.

Prompt #3: Layout structure reverse-engineer

What it does: Takes a screenshot or HTML and maps out the full layout architecture: grid system, section structure, component nesting and responsive breakpoint logic.

When to use it: Before building any page that has a layout you want to understand or replicate structurally.

The prompt:

Analyse the layout structure of this page as if you're an engineer who needs to
rebuild it from scratch.

Produce:

1. Section map: list every distinct vertical section of the page from top to bottom.
   For each section: what is its purpose, what is its approximate height behaviour
   (fixed/content-driven/viewport), and what layout method does it appear to use
   (flexbox, grid, absolute positioning)?

2. Grid breakdown: for the most complex section on the page, describe the column
   structure in enough detail that a developer could write the CSS grid or flexbox
   rules to recreate it.

3. Component nesting: pick the most interesting component on the page and describe
   its internal structure as a nested list (outer container > row > left column >
   icon + text stack, etc.)

4. Responsive logic: based on what you can see, how do you think this layout
   changes at mobile widths? What likely collapses, stacks or hides?

5. One-sentence summary of the overall layout philosophy (e.g. "constrained-width
   centred container with full-bleed section backgrounds").

[PASTE SCREENSHOT OR HTML]

How to use it:

1. Use on full-page screenshots for the section map, or paste the page’s HTML for more precise component nesting

2. Pay particular attention to the grid breakdown output. That’s the hardest part to eyeball yourself

3. Use the responsive logic section as your mobile design brief

Example input: Screenshot of Notion’s marketing homepage.

What you’ll get: A section map with eight distinct blocks, a detailed grid breakdown of their feature comparison section (12-column base, 3-column at desktop, single column at mobile), a nested component description of their “block” illustration card, and a layout philosophy summary: “full-width sections with an 1100px max-width inner container, heavy use of alternating light/dark backgrounds to create rhythm.”

Advanced note: After the layout breakdown, ask Claude to write the HTML skeleton with semantic tags and BEM class names. You get a buildable scaffold in about 60 seconds.

You just got 3 prompts for extracting the visual layer, the code layer and the layout logic from any site.

The next 7 prompts go deeper:

• How to extract the exact copywriting patterns and voice behind any site’s headlines

• How to reverse-engineer the microcopy (buttons, tooltips, empty states, error messages)

• How to clone a full component in working code from a screenshot alone

• How to extract the animation and interaction logic without touching JavaScript

• How to build a complete competitor teardown document in one session

• How to generate a “stolen” style guide you can hand to any developer

• Plus: a full replication workflow template that chains all 10 prompts in sequence

Subscribe now

Prompt #4: Copywriting pattern extraction

What it does: Reverse-engineers the copywriting formula behind any site’s headlines, subheads, CTAs and feature descriptions so you can apply the same structure to your own product.

When to use it: When a competitor’s copy converts well and you want to understand the formula, not just admire it.

The prompt:

I'm going to share copy from a website. Analyse it as a direct-response copywriter
studying a competitor.

Extract:

1. Headline formula: what pattern does each headline follow? (e.g. "[outcome] for
   [audience] without [pain]", "[verb] your [noun] in [timeframe]") Write the
   abstract formula, then show the example from the page.

2. Value proposition structure: how do they sequence benefit claims? Features first
   or outcomes first? Specific or aspirational?

3. CTA language: list every call-to-action button text on the page. What verb tense?
   What commitment level do they imply (low-friction vs high-commitment)?

4. Social proof patterns: how do they use testimonials, logos or numbers? What
   specifically do they claim (not vague praise but measurable outcomes)?

5. Objection handling: where on the page do they address likely hesitations?
   What objections are they pre-empting?

6. Voice profile: write 5 adjectives that describe the writing voice, then write
   2 sentences in that voice about a fictional product to demonstrate you've
   captured it.

Here is the copy:
[PASTE ALL TEXT FROM THE PAGE]

How to use it:

1. Select all text on the page (Ctrl+A, Ctrl+C in most browsers) or use a reader mode to get clean text

2. The voice profile at the end is the most portable output. Save it and use it in future writing sessions

3. Run this on your own site too. The gap between your formula and theirs is your rewrite brief.

Example input: All copy from Framer’s homepage.

What you’ll get: Headline formula identified as “[outcome]-first, tool-second” (they lead with what you’ll build, not what Framer is), CTA language catalogued as low-friction present-tense (”Start for free”, “See examples”), objection handling located in the FAQ section addressing the “is this just for designers?” concern, and a voice profile: “confident, minimal, slightly irreverent, product-obsessed, anti-corporate” with two demonstration sentences in that voice.

Advanced note: After the voice profile, ask Claude to rewrite your own homepage hero section in the competitor’s voice. Then ask it to identify which specific changes made the biggest difference. That gap analysis is your actual copywriting brief.

Prompt #5: Microcopy audit

What it does: Extracts and analyses all the small-copy decisions on a site: button labels, placeholder text, error messages, empty states, tooltips and confirmation messages.

When to use it: When a product feels polished and you can’t quite work out why. The answer is usually microcopy.

The prompt:

I'm going to share microcopy from a product interface. Analyse it as a UX writer
studying how a product communicates in the smallest moments.

Catalogue and analyse:

1. Button and action labels: list them all. What verb patterns do they use?
   Do they describe the action or the outcome?

2. Placeholder text: is it instructional, aspirational or example-based?
   Does it stay visible during input or disappear?

3. Error messages: how do they handle mistakes? Blame the user or own the problem?
   Do they tell you what went wrong and what to do next?

4. Empty states: what do they show when there's no content yet? Is it helpful,
   playful or just blank?

5. Confirmation and success messages: how do they celebrate completions?
   Functional or warm?

6. Tooltip and helper text: where do they add context? How long are they?

7. Overall microcopy philosophy: write one paragraph describing the personality
   and principles behind the writing, as if you were briefing a new UX writer
   joining the team.

Here is the microcopy:
[PASTE ALL UI TEXT FROM THE INTERFACE]

How to use it:

1. Go through the product you’re studying and copy every piece of text that isn’t marketing copy or content: labels, placeholders, errors, confirmations

2. The “overall philosophy” paragraph at the end is worth keeping as a writing brief

3. Compare the error message patterns to your own product. This is usually where the biggest gaps are

Example input: Microcopy from Superhuman’s email interface.

What you’ll get: A catalogue showing Superhuman uses outcome-based button labels (”Done” not “Mark as read”), aspirational placeholders (”Search everything”), warm and brief confirmation messages, a notably absent error state (by design, since the product is engineered to prevent errors rather than handle them gracefully), and a philosophy paragraph that reads: “Write for speed. Every word is a tax on the user’s attention. Celebrate momentum. Never explain what the interface already shows.”

Advanced note: After the audit, ask Claude to apply the same microcopy philosophy to your own interface. Give it your current button labels and error messages and ask for rewrites in the studied product’s voice. You’ll see immediately what “high craft” microcopy feels like compared to what most products ship.

Prompt #6: Component clone from screenshot

What it does: Takes a screenshot of any UI component and produces working HTML and CSS that replicates its structure, spacing and visual style.

When to use it: When you see a card, nav, hero block or form you want to build and you’d rather start from a working clone than a blank file.

The prompt:

I'm going to share a screenshot of a UI component. Build me a working HTML and CSS
replica of it.

Requirements:
- Semantic HTML5 elements where appropriate
- CSS using custom properties for all colours, spacing and typography values
- No external dependencies unless the original clearly uses an icon library
- Mobile-responsive by default
- Comments in the CSS explaining any non-obvious decisions

After the code, write a short note on:
- What you approximated (where you couldn't be precise from the screenshot)
- What you'd need to know to make it pixel-perfect
- One improvement you'd suggest over the original

Screenshot: [ATTACH COMPONENT SCREENSHOT]

How to use it:

1. Crop your screenshot tightly to just the component you want. Don’t include surrounding page chrome

2. The “what I approximated” note at the end is useful for prioritising where to spend time refining

3. Paste the output into a CodePen or local file to test immediately

Example input: Screenshot of a pricing card from Vercel’s pricing page.

What you’ll get: Working HTML with a card wrapper, plan name, price display, feature list and CTA button, CSS custom properties for the dark surface colour, accent border treatment and spacing, mobile-responsive layout, and a note flagging that the exact font weight on the price figure was estimated at 700 and the precise box-shadow spread couldn’t be confirmed from the screenshot.

Advanced note: After the first clone, ask Claude to produce a variant: “now give me a highlighted/featured version of the same card that would work as the ‘recommended’ option.” You get a complete pricing card set without starting over.

Prompt #7: Animation and interaction logic extraction

What it does: Reverse-engineers the motion design and interaction patterns from a site’s animations without needing to read the JavaScript source.

When to use it: When a site’s interactions feel premium and you want to understand what’s creating that feeling.

The prompt:

I'm going to describe the animations and interactions I've observed on a website.
Reverse-engineer the likely implementation and give me working CSS and/or JS to
recreate the effect.

For each interaction I describe:
1. Identify what CSS properties are likely being animated
2. Identify the trigger (hover, scroll, load, click)
3. Estimate the duration and easing curve that would produce this feel
4. Write the CSS transition or animation, or minimal vanilla JS if required
5. Note any performance considerations (stick to transform and opacity where possible)

Interactions to reverse-engineer:
[DESCRIBE EACH ANIMATION IN PLAIN ENGLISH, E.G.:
- Cards lift slightly and show a shadow on hover, with a very short delay
- The hero headline fades in word by word on page load
- The nav shrinks and gains a background blur as you scroll down]

How to use it:

1. Spend five minutes on the site you’re studying, watching each interaction carefully before describing it

2. Describe what you see, not what you think the code does. Claude will infer the implementation

3. Test the output in isolation before integrating; animation timing often needs adjustment to context

Example input: Describing three interactions from Loom’s marketing site: card hover lifts, scroll-triggered section fades, and a sticky nav with blur backdrop.

What you’ll get: CSS for the card lift using transform: translateY(-4px) with box-shadow transition at 200ms ease-out, an Intersection Observer setup for the scroll fades with staggered animation-delay per element, and the sticky nav using position: sticky with backdrop-filter: blur(12px) triggered by a scroll class toggle.

Advanced note: After getting the implementations, ask Claude to audit them for performance. It will flag any that trigger layout recalculation (the expensive kind) and suggest property swaps that keep the same visual result with better frame rates.

Prompt #8: Full competitor teardown

What it does: Produces a structured competitive analysis document from a single session studying one site, covering design, copy, UX, positioning and what you can steal versus what you should avoid.

When to use it: Before a redesign, a new product launch, or any time a competitor is outperforming you and you want to know specifically why.

The prompt:

I'm going to share information about a competitor's site. Produce a full teardown
document structured as follows:

**First impression (10 seconds)**
What does the site communicate in the first 10 seconds? What problem does it solve,
for whom, and why should you care? Could a confused first-time visitor answer those
three questions without scrolling?

**Design strengths**
3-5 specific design decisions that are working well. Be precise. Not "clean layout"
but "the use of 80% whitespace in the hero creates immediate visual hierarchy that
draws the eye to the single CTA."

**Copy strengths**
3-5 specific copy choices that are effective. Quote the actual line and explain why
it works.

**UX friction points**
Where does the experience break down? What requires more clicks than it should?
What's confusing or missing?

**What to steal**
Specific, actionable things worth replicating in your own work. Not the aesthetic
but the decision.

**What to avoid**
Mistakes or choices that don't serve users well, with a brief explanation of why.

**Competitive positioning gap**
What space does this product NOT occupy that could be claimed?

Here is what I've gathered about the site:
[PASTE SCREENSHOTS, COPY, AND YOUR OWN OBSERVATIONS]

How to use it:

1. Spend 20-30 minutes on the competitor’s site before running this prompt. Your observations are as important as the raw material you paste in

2. The “what to steal” section is the deliverable; everything else is context

3. Run this on your own site too, as if you were a competitor studying you

Example input: Screenshots, copy and observations from a competitor SaaS product in the project management space.

What you’ll get: A structured eight-section teardown identifying their first impression as clear but slow (the hero takes four seconds to load its animation), three specific design strengths including their use of customer logo placement to create social proof before the fold, two copy lines worth studying, two UX friction points, five concrete things to steal and a positioning gap observation: they own “enterprise teams” but leave “solo operators who’ve outgrown spreadsheets” entirely unaddressed.

Advanced note: After the teardown, ask Claude to write a one-page brief summarising the single biggest opportunity the competitor has left open. That brief is the starting point for your own positioning work.

Prompt #9: Style guide generator

What it does: Takes everything extracted in the previous prompts and compiles it into a single, shareable style guide document a developer or designer can work from immediately.

When to use it: At the end of a replication or redesign session, when you need to hand off direction to someone else or document your decisions for future reference.

The prompt:

I'm going to paste design decisions, tokens and patterns I've extracted from a site
I've been studying. Compile them into a clean, shareable style guide document.

The document should include:

**Brand personality** (3 sentences describing the visual and verbal identity)

**Colour system**
Primary, secondary, neutral and semantic colours with hex values.
Brief usage note for each (e.g. "primary: use for interactive elements and CTAs only").

**Typography**
Font choices, size scale, weight usage, line height guidelines.
Show the scale visually using markdown heading levels where possible.

**Spacing system**
The base unit and scale. Show as a table.

**Component patterns**
Brief description of 3-5 key components with their design rules.

**Copy voice**
5 adjectives. 3 rules (e.g. "never use passive voice", "lead with the outcome").
One before/after example.

**What to use this for**
One paragraph on how to apply this guide to a new project without making it
look like a direct copy.

Here is the extracted material:
[PASTE YOUR OUTPUTS FROM PREVIOUS PROMPTS IN THIS SESSION]

How to use it:

1. This prompt works best at the end of a session where you’ve already run several earlier prompts. Paste in those outputs as the raw material

2. The “what to use this for” section is important: it frames the guide as a learning tool rather than a copy-paste template

3. Export the output as a PDF or Notion doc to share with collaborators

Example input: Outputs from prompts 1, 2, 4 and 5 in this article, all run on the same site in a single Claude session.

What you’ll get: A complete four-page style guide covering brand personality, a full colour token table, a typographic scale, an 8px-based spacing system, five component patterns with rules, a copy voice section with three writing rules and a before/after example, and a closing paragraph reframing the guide as an influence document rather than a replication manual.

Advanced note: After generating the style guide, ask Claude to identify the three decisions in it that are most distinctive to the original site and would be most recognisable as “borrowed.” Those are the ones to consciously replace with your own decisions when applying the guide to new work.

Prompt #10: Full replication brief

What it does: Combines everything from the session into a single, structured brief that a developer can use to build a new site or app that’s informed by your studied design, without being a copy of it.

When to use it: When you’re ready to build and need a single document that captures all your decisions rather than a scattered set of notes.

The prompt:

I've spent a session studying a site I admire and extracting its design decisions.
Now I want to use those lessons to build something new. Write a full build brief
for my project.

My project:
[DESCRIBE WHAT YOU'RE BUILDING IN 3-5 SENTENCES]

Target audience:
[WHO WILL USE IT AND WHAT DO THEY CARE ABOUT]

What I've learned from the site I studied:
[PASTE KEY OUTPUTS FROM THIS SESSION]

The brief should include:

**Project overview** (what this is and who it's for)

**Design direction** (what to steal and how to make it your own; be specific about
where to stay close to the reference and where to deliberately diverge)

**Technical stack recommendation** (based on the complexity and patterns observed)

**Page-by-page build list** (which pages to build, in what order, with priority)

**Component build list** (which components to build first, with complexity rating)

**Copy direction** (voice, headline approach, CTA strategy)

**Definition of done** (what does "finished" look like for version 1?)

How to use it:

1. Write a clear project description before running this. Vague input produces vague briefs

2. The “design direction” section is the most important: it’s where influence becomes original work

3. Hand the complete output to a developer as the project brief, or use it as your own build checklist

Example input: A founder building a SaaS landing page for a solo developer tool, having studied Linear’s marketing site throughout this session.

What you’ll get: A structured brief covering a dark-surface design direction informed by Linear’s palette but with a warmer accent colour and more editorial typography, a three-page build list (landing, pricing, docs) with the landing page broken into six sections and prioritised, a component list with complexity ratings, a copy direction that takes Linear’s “built for focus” voice but applies it to a solo rather than team context, and a definition of done covering performance benchmarks and conversion elements for launch.

Advanced note: After the brief, ask Claude to write the first section of the landing page in full, using the brief as its only instruction. If it produces something that feels right, the brief is clear enough to build from. If it goes sideways, revise the brief before handing it to anyone else.

Implementation guide: running the full workflow

These 10 prompts work as a sequential pipeline. Here’s how to run them in one session:

Phase 1: Reconnaissance (Prompts 1-3) Start with the visual audit (screenshot), then pull the CSS tokens (source code), then map the layout structure. By the end of phase 1 you have a complete technical picture of the site’s design layer.

Phase 2: Language and interaction (Prompts 4-5, 7) Extract the copy patterns, catalogue the microcopy, then document the animations. This phase gives you the verbal and motion layers that most replication projects miss entirely.

Phase 3: Build output (Prompts 6, 9-10) Clone the component you most want to replicate, compile everything into a style guide, then write the build brief. You leave the session with working code, a shareable document and a project brief.

Where Prompt 8 fits: The competitor teardown (Prompt 8) is a standalone exercise. Run it at the start of a project to inform what you study, or at the end to sense-check whether your brief has addressed the gaps you found.

Keep everything in one Claude session if you can. Context carries forward and later prompts benefit from what was established earlier.

Bonus: replication session starter

Paste this at the top of any replication session to set Claude’s context before you start:

I'm starting a design replication session. I'm going to study [SITE NAME] to
understand the design decisions behind it and apply those lessons to [MY PROJECT].

Throughout this session:
- Be specific and technical, not vague and inspirational
- Give me code I can use, not just descriptions
- When you estimate something you can't confirm, say so
- Point out decisions that are unusual or distinctive, not just standard practice
- Keep outputs structured so I can paste them into later prompts in this session

Let's start.

This primes Claude for the technical register the later prompts need. Without it, early responses sometimes drift toward design commentary rather than extractable decisions.

Advanced tips

Screenshot quality matters more than you think. Use a full-page screenshot tool (GoFullPage for Chrome works well) rather than a browser crop. Higher resolution means Claude can read font weights, spacing and subtle colour differences more accurately.

Pair this workflow with real DevTools time. Claude does the analysis; DevTools gives you the ground truth. When the two disagree, trust DevTools. When Claude notices something you hadn’t spotted in DevTools, investigate it.

Study sites outside your category. The most interesting design decisions to steal are rarely from direct competitors. A fintech founder who studies Notion’s information hierarchy learns more than one who only looks at other fintech products.

Build a personal reference library. After each replication session, save the style guide output (Prompt 9) with the site name and date. After ten sessions you have a reference library of analysed design systems you can pull from without re-running the workflow.

Claude’s image analysis has limits. It reads layout, spacing and colour well. It struggles with fine-grain font identification and precise pixel measurements. For type identification, use WhatFont or Fontface Ninja in the browser alongside this workflow.

DISCLAIMER

The information is intended to be helpful, but is in no way a substitute for seeking professional advice for your specific situation or intent. This applies to business, financial, legal, health, medical, personal, or other matters discussed herein. Please read the full DISCLAIMER

Copyright Notice

The information in this document is protected by international copyright laws. You may use the information for personal purposes, but you are not permitted to duplicate it or distribute it to anyone else. This copy is for you only.

I published a free briefing this week over at the AI Governance Playbook. Eleven pages covering the EU, US and UK. What’s in force, what’s coming, and what actually requires action on your part.

A few things that will likely surprise you. The EU’s opt-out system for AI training data puts the responsibility entirely on you. If you haven’t published a machine-readable rights reservation, EU law currently allows AI companies to train on your public content. The opt-out exists, but you have to activate it.

In the US, the $1.5 billion Bartz v. Anthropic settlement in January drew a line that changes the calculation for every AI company acquiring training data. Pirated sources are no longer a fair use defence. That ruling has ripple effects for creators whose work appeared in shadow libraries without their knowledge.

The UK ran what may be the longest copyright consultation in recent memory, got 11,500 responses, then rejected the opt-out model it had been developing for two years. No new law yet. A market pilot instead.

There’s also a cross-border checklist on page 10 with eight actions you can take today, most of them free, all of them worth doing if you publish anything online.

Download it free!

AI Regulation for Creators - Spring 2026

DISCLAIMER

The information is intended to be helpful, but is in no way a substitute for seeking professional advice for your specific situation or intent. This applies to business, financial, legal, health, medical, personal, or other matters discussed herein. Please read the full DISCLAIMER

Copyright Notice

The information in this document is protected by international copyright laws. You may use the information for personal purposes, but you are not permitted to duplicate it or distribute it to anyone else. This copy is for you only.

Claude Skills fixes that.

A Skill is a small folder of instructions you build once and upload to Claude. After that, Claude loads it automatically whenever you’re doing the kind of work it covers. No re-prompting. No re-explaining. You describe what you need, Claude recognises the task, loads the right instructions, and runs your workflow.

For product managers specifically, this changes things considerably. The prompts you’d normally type from scratch become repeatable systems. Your PRD template, your stakeholder prep process, your research synthesis format - all of it lives in Claude and fires when you need it.

This article covers 8 Skills worth building if you’re a PM. Each one comes with a real scenario, the prompt logic behind it, and a look at what the actual Skill file contains so you can build it yourself.

How to build a Skill (the short version)

A Skill is a folder with one required file: skill.md. That file has two parts - a short header block that tells Claude when to load the Skill, and the body that tells Claude what to do once it loads.

The header looks like this:

---
name: your-skill-name
description: What it does and when to use it. Use when user asks to [specific phrases].
---

The description is the most important thing you’ll write. Claude reads it to decide whether your Skill is relevant to what you’re asking. Vague descriptions mean the Skill either never loads or loads at the wrong time. Specific ones - including the phrases you’d actually type - work reliably.

Once your folder is ready, zip it and go to Settings > Capabilities > Skills > Upload [‘Skills’ now moved to ‘Customise’] in Claude.ai. Code execution needs to be on for Skills to work. You’ll find that toggle in the same Capabilities section.

Now, the 8 Skills.

Skill #1: Discovery notes to requirements

What it does: Takes raw, messy stakeholder notes and turns them into a structured requirements document with contradictions flagged rather than silently resolved.

When it loads: When you paste in discovery notes, meeting transcripts or anything that looks like unstructured input and ask Claude to turn it into requirements.

The scenario:

Sarah just ran a 90-minute discovery call with sales, customer success and two enterprise clients. Her Notion page is full of half-sentences. She has a voice memo transcript, four Slack messages from stakeholders adding things they forgot, and one comment from Legal that says “GDPR thing — need to follow up” with nothing else. She opens Claude, pastes everything in and types “extract requirements from these notes.”

The Skill loads automatically. Claude doesn’t need her to explain the format she wants or what sections to include. It already knows.

The SKILL.md:

markdown

---
name: pm-requirements-extractor
description: Extracts structured requirements from messy discovery notes, stakeholder
inputs, meeting transcripts or Slack threads. Use when user pastes raw notes and asks
to "extract requirements", "structure these notes", "turn this into a requirements doc"
or similar.
---

# Requirements extractor

When given raw discovery notes or stakeholder input, produce a structured requirements
document with these sections:

**Core problem being solved**
One clear sentence. If the notes don't agree on this, say so.

**User needs**
Who wants what and why. One line per need. If the same need appears from multiple
sources, note how many mentioned it.

**Functional requirements**
What the product must do. Number them. Write in plain language.

**Constraints and non-negotiables**
Technical, legal, resource or timeline limits that are fixed.

**Open questions**
Anything vague, contradictory or incomplete. Frame as questions to be answered,
not problems. These become the agenda for the next stakeholder meeting.

Rules:
- Where stakeholders contradict each other, flag the contradiction explicitly.
  Do not pick a side or average the two positions.
- Where something is vague, add it to open questions. Do not invent specifics.
- Keep language plain. No jargon unless the user's notes used it.

What Sarah gets: A clean doc where the SSO vs reporting priority conflict is called out directly, the GDPR comment becomes a specific open question (”What did Legal mean by ‘GDPR thing’? Needs follow-up before any data handling decisions”), and functional requirements are separated from the noise.

Advanced note: After the requirements doc is generated, paste it back in with “rank these by user impact versus implementation effort.” You get a rough prioritisation view without opening a separate session.

Skill #2: PRD first draft

What it does: Writes a complete product requirements document from a brief description of what you’re building, in your team’s format, every time.

When it loads: When you ask Claude to write a PRD, spec or product requirements document.

The scenario:

Marcus leads product at a fintech startup. His CTO wants a PRD for a new transaction alerts feature by end of week. Marcus has the idea clear in his head and a few rough notes. He knows writing from scratch takes half a day. He opens Claude and types “write a PRD for real-time transaction alerts.” The Skill loads, asks two clarifying questions, and delivers a full draft in about 10 minutes.

He spends the rest of his time editing rather than writing.

The SKILL.md:

markdown

---
name: pm-prd-writer
description: Writes product requirements documents from brief descriptions. Use when
user asks to "write a PRD", "draft a spec", "create product requirements" or describes
a feature and wants it documented formally.
---

# PRD writer

Before writing, confirm these if not already provided:
1. What is the product and who uses it? (2 sentences max)
2. What are the known technical or resource constraints?

If context is already clear from the conversation, skip to the PRD.

## PRD structure

**Problem statement**
What user problem does this solve? Why now?

**Goals and success metrics**
2-3 measurable outcomes. Include how each will be measured.

**User stories**
Minimum 5. Format: "As a [user type], I want to [action] so that [outcome]."
Write for at least two different user types.

**Functional requirements**
Numbered list. Plain language. One requirement per line.

**Out of scope**
Explicit list of related things this feature will NOT include.
This section is as important as the requirements themselves.

**Open questions**
Anything that needs a decision before development can start.

Rules:
- Plain language throughout. No technical jargon unless the user used it.
- Out of scope section must include at least 3 items.
- Do not write vague success metrics. Write measurable ones with a number attached.

What Marcus gets: A full seven-section PRD with user stories covering at least two user types, plus an out-of-scope section that flags joint accounts, bill splitting and savings goals before anyone raises them in the review meeting.

Advanced note: Once the draft is done, ask Claude to read it as a senior engineer seeing it for the first time. Ask what questions they’d have. You’ll surface ambiguities before sprint planning rather than during it.

You just got 2 Skills that turn raw input into structured PM output.

But the heavier work in product is everything that happens after the doc exists — getting stakeholders aligned, handling pushback, writing for different audiences, making prioritisation calls under pressure.

The next 6 Skills cover that:

• A roadmap narrative Skill that explains your sequencing decisions before anyone asks

• A stakeholder prep Skill that generates the hardest questions you’ll face and helps you answer them honestly

• A user research Skill that synthesises interview notes into findings in minutes

• A spec review Skill that reads your spec as an engineer would and flags every ambiguity

• A prioritisation Skill that argues against your own decision so you find the holes first

• Plus: a one-page alignment template you can use before any major review

Upgrade to get the complete system.

Skill #3: Roadmap narrative builder

What it does: Turns a list of roadmap items into a coherent narrative for exec, board or all-hands presentations - one that explains the sequencing logic and addresses likely pushback before it happens.

When it loads: When you paste a roadmap list and ask Claude to write a narrative, presentation story or exec summary of your roadmap.

Read more

Meanwhile, a smaller group is pulling outputs that would’ve taken $500 and three days to get done another way, in 20 minutes flat.

The difference is the prompt.

This article gives you 8 prompts that put you in that second group. Each one targets a specific failure mode: AI that hedges instead of commits, output that sounds nothing like you, conversations that drift and get worse the longer they run.

First prompt is up.

Prompt #1: Persona injection

What it does: Locks the AI into a specific expert role before it answers, so the output comes filtered through real expertise rather than generic “helpful assistant” mode.

When to use it: Any time the default output feels too broad or too shallow. Consulting advice, specialist writing, technical reviews.

The prompt:

You are a [SPECIFIC ROLE] with [X YEARS] of experience in [SPECIFIC INDUSTRY/NICHE].
You have worked with [TYPE OF CLIENT/COMPANY] and you specialise in [SPECIFIC PROBLEM AREA].

Before you answer anything, think from that expert's perspective. What would you notice
that a generalist would miss? What assumptions would you immediately push back on?

Now, with that hat on: [YOUR ACTUAL QUESTION OR TASK]

How to use it:

1. Fill in the role, years, industry and specialisation with as much specificity as you can

2. Don’t rush to the actual question - the setup is doing real work

3. Ask your question at the end, after the persona is set

Example input:

You are a direct-response copywriter with 15 years of experience in SaaS and B2B software.
You have worked with funded startups trying to reduce churn and improve trial-to-paid
conversions. You specialise in onboarding emails and in-app messaging.

Before you answer anything, think from that expert's perspective. What would you notice
that a generalist would miss? What assumptions would you immediately push back on?

Now, with that hat on: Review this onboarding email sequence and tell me what's killing
conversions. [PASTE EMAIL]

What you’ll get: A review that doesn’t just say “be clearer.” You get the kind of pointed, uncomfortable feedback a specialist charges real money for.

Advanced note: Stack two personas for useful tension. Something like “You are both a direct-response copywriter AND a UX researcher who thinks copy problems are usually symptoms of UX problems.” The internal conflict produces more interesting outputs than either persona alone.

Prompt #2: Pre-mortem pressure test

What it does: Stress-tests your plan by imagining it already failed, then works backwards to explain why.

When to use it: Before you launch anything that’s hard to undo. A product, a campaign, a pitch.

The prompt:

I'm about to [DESCRIBE YOUR PLAN OR DECISION IN 2-3 SENTENCES].

Run a pre-mortem on this. Assume it's 12 months from now and this failed badly — not
mediocre, actually failed. What went wrong? Give me the top 5 specific failure modes,
ranked by likelihood. For each one: what would the early warning sign have been, and what
can I do now, before I start, to reduce that risk.

Don't be polite. I'd rather know the ugly version now.

How to use it:

1. Describe your plan in plain language - no need to sell it to the AI

2. Keep the 12-month frame; it’s far enough out that you get real risks, not surface-level cautions

3. After you get the failure modes, ask: “Which of these am I most likely to ignore because I’m too close to it?”

Example input:

I'm about to launch a paid newsletter on Substack focused on AI tools for solopreneurs.
I'm planning to charge $15/month and post twice a week. I have about 400 email subscribers
already and a small LinkedIn following.

Run a pre-mortem on this. Assume it's 12 months from now and this failed badly. What went
wrong? Give me the top 5 specific failure modes, ranked by likelihood...

What you’ll get: A frank ranked list of what kills newsletters like yours, with early warning signs you can actually track. Often surfaces the thing you already knew but hadn’t said out loud.

Advanced note: After the pre-mortem, run a “pre-win” with the same structure but imagining it succeeded beyond expectations. Ask what would have had to be true. The contrast between the two outputs is genuinely useful.

You just got 2 prompts that change how you set up and pressure test any AI task.

But most prompting problems happen mid-conversation - when AI goes vague, loses your context, starts hedging, or gives you a wall of text when you needed one sharp answer.

The next 6 prompts handle that:

• How to force a specific answer when AI keeps dodging

• How to recover when a long thread has gone sideways

• How to get AI to rewrite your work without losing your voice

• How to make AI reason out loud before it commits to an answer

• Plus: a prompt repair template you can paste onto any underperforming prompt to fix it

Upgrade to get the complete system.

Prompt #3: Specificity demand

What it does: Breaks AI’s habit of hedging with “it depends” by forcing it to commit to one recommendation with actual numbers.

When to use it: When you ask for advice and get “there are several factors to consider” back.

Read more

It’s not a creativity problem. It’s a depth problem. Any world has thousands of moving parts: history, factions, economies, religions, geography, social codes. No one person can build all of that before session one. Usually you build enough to start and hope players don’t wander too far off-script.

These 10 prompts change that. They’re designed for worldbuilders who want a living, internally consistent setting, the kind where players can ask unexpected questions and the answer already exists somewhere in the logic of the world. You’re not generating content to fill a wiki. You’re generating the underlying rules that make consistent content possible.

Work through them in order. Each one builds on the last.

What you’ll get

A fully realized world with grounded geography, a creation myth that shapes culture, working faction dynamics, a believable economy, a magic or power system with real constraints, social rules players can discover through play, a pantheon that behaves like one, a living history with unresolved tensions, a distinct regional voice for your NPCs, and a one-page world reference you can keep at the table.

Prompt 1: The founding pressure

What it does: Establishes the core survival problem that shaped everything else about your world, its geography, its culture, its values.

When to use it: Before anything else. This is the load-bearing wall. Everything you build later should feel like a response to this.

The prompt:

I'm building a world for a [TTRPG SYSTEM / NOVEL / CAMPAIGN]. Here are the basic parameters:

Setting type: [FANTASY / SCI-FI / HISTORICAL / OTHER]
Tone: [DARK / HOPEFUL / GRITTY / MYTHIC / OTHER]
One-sentence premise: [WHAT THE WORLD IS ABOUT IN PLAIN TERMS]

Help me develop the founding pressure of this world -- the core environmental, political, or existential problem that the earliest civilizations had to solve. This is the pressure that explains why cities are where they are, why certain beliefs took hold, why specific social structures emerged.

Give me:
1. The founding pressure in 2-3 sentences
2. Three ways it shaped early civilization (settlement patterns, belief systems, social hierarchies)
3. Whether the pressure has been resolved, is ongoing, or has transformed into something new
4. One unintended consequence of how people adapted to it

Be specific. Avoid generic fantasy tropes unless they serve the premise.

How to use it:

1. Fill in the parameters honestly: “I don’t know yet” is a valid answer for tone or premise, just say so and let the model help

2. The unintended consequence in #4 is often the most useful output because it gives you built-in irony and player hooks

3. Save the full output; every later prompt will reference it

Example input: Setting type: Fantasy. Tone: Gritty, low magic. Premise: A seafaring empire built on slave labor is starting to collapse from within.

What you’ll get: A founding pressure that explains why the empire expanded, how slavery became normalized, what belief systems justify it, and what’s now corroding the structure from inside.

Pro tip: If the founding pressure feels too abstract, ask the model to make it sensory, “what does this pressure smell like, sound like, look like in daily life?” That question produces details you can actually hand to players.

Prompt 2: The creation myth

What it does: Builds a creation myth that is believed by your world’s inhabitants, not a cosmological fact, but a story that shapes how people interpret everything around them.

When to use it: After Prompt 1. The creation myth should be a cultural response to the founding pressure, not a neutral description of how the world came to be.

The prompt:

Here is the founding pressure of my world:

[PASTE OUTPUT FROM PROMPT 1]

Now write a creation myth that the dominant culture of this world believes. This myth should:

1. Explain or justify the founding pressure (why does it exist? whose fault is it? what does it mean?)
2. Establish a moral framework -- who are the heroes, who are the villains, what is the correct way to live?
3. Contain at least one element that can be interpreted two ways -- one reading that supports the powerful, one that could be used to challenge them
4. End with a prophecy or recurring sign that believers watch for in the present day

Write it as a myth -- narrative voice, not bullet points. Aim for 300-400 words. Then add a brief note on which social class or group uses each interpretation of the ambiguous element.

How to use it:

1. Read the myth as your players might hear it, as a bedtime story, a temple inscription, a piece of propaganda

2. The ambiguous element is a faction seed; you’ll develop it properly in Prompt 4

3. The prophecy or sign gives you a recurring motif you can drop into play without explanation

Example input: Founding pressure: The empire expanded because coastal lands couldn’t feed a growing population. Slavery was justified as “redemption through service.” The system is now straining because generations of enslaved people have developed skills the empire can’t replace.

What you’ll get: A 300-400 word myth in narrative voice, a built-in interpretive conflict, and a recurring sign players will start noticing in the fiction.

Pro tip: Run this prompt twice with different dominant cultures. The second myth, from a marginalized perspective, is usually more interesting and gives you an immediate source of tension.

Prompt 3: The physical world

What it does: Builds a geography that feels earned, where terrain, climate and resources create the conditions for the history you’ve already established.

When to use it: After Prompts 1 and 2. Geography should explain how the founding pressure became possible, not just provide a backdrop.

The prompt:

Here is my world's founding pressure and creation myth:

[PASTE OUTPUTS FROM PROMPTS 1 AND 2]

Now build the physical world. I need geography that makes the history feel inevitable -- where terrain, climate, and resources created the conditions for everything that came before.

Give me:
1. Two or three dominant geographic features and how they shaped early movement and settlement
2. The resource that everything valuable runs on (could be material, agricultural, magical, informational)
3. One geographic feature that is contested -- multiple groups want it or need it
4. The weather or seasonal pattern that defines the rhythm of life
5. A region that most people avoid and why -- not because it's evil, but because it's dangerous, unknown, or simply not worth the cost

Avoid generic maps. Make it feel like the terrain was designed by history, not by a dungeon master filling in blank space.

How to use it:

1. The contested feature from #3 is your most useful output, it’s a conflict that already exists and doesn’t need you to manufacture a villain

2. The avoided region is where you put things that don’t fit the main narrative yet; players will eventually go there

3. Use this output to sketch a rough map, even just on paper, spatial thinking changes how you plan encounters

Example input: Founding pressure and myth from the collapsing slave empire example.

What you’ll get: A physical world where the empire’s coastal expansion, resource dependency, and current instability all make geographic sense.

Pro tip: Ask the model to add one geographic feature that currently exists but didn’t during the founding period, something that appeared, shifted, or was revealed over time. That feature is your mystery hook.

You just built the bones of a world: the pressure that created it, the story people tell about it, and the terrain it sits on.

But a world without people is a diorama. The next seven prompts build the living parts, the factions fighting over power, the economy explaining who has it, the magic system defining its limits, the social codes players can break, the gods who actually show up, the history that isn’t finished yet, the voices that make each region distinct, and the one-page reference that ties it all together.

Upgrade to get the complete system.

Read more

The problem isn’t effort. It’s that raw feature lists don’t tell you what to say. You can document everything Monday.com does and still have no idea how to position against them.

These 8 prompts are built around that gap. You start with features, but you end with positioning language you can actually use on your homepage, your sales calls, and your comparison pages. I’ve structured them so each one feeds the next, so you’re not starting from scratch at each step.

Plan for about 90 minutes. You’ll need your product knowledge and three to five competitors to analyze.

What you’ll get

A structured map of where the market is weak, a ranked list of the gaps your product actually fills, five positioning statements written against real competitor failures, a profile of the customer most likely to switch to you, and a one-page brief you can hand to anyone who writes copy or closes deals for you.

Prompt 1: Competitor feature inventory

What it does: Builds a structured feature table for one competitor, rated across six categories.

When to use it: At the start, before you’ve compared anything. Run it once per competitor.

Read more

When something goes sideways (a business bet taking longer than expected, a career move that feels less certain three months in), most people can’t remember exactly what they believed when they made the decision. So they relitigate the whole thing. Was it the right call? Should I have known better? They’re not questioning the decision so much as the reasoning behind it, and that reasoning has gone fuzzy.

The fix isn’t more conviction. It’s a record. Specifically, a log of the assumptions your decisions were built on, updated as evidence comes in, readable by an AI that can tell you whether your current doubt is signal or noise.

That’s what this article builds.

What You’ll Get

By the end you’ll have:

• An assumptions log template structured for AI to reason about, not just store

• A prompt that reverse-engineers the assumptions underneath decisions you’ve already made

• A maintenance prompt that maps new evidence to existing beliefs and updates their status

• A second-guess audit prompt that tells you whether your doubt is real or just anxiety

• A stale assumptions scanner that finds decisions still in force built on beliefs that no longer hold

• A pre-decision capture prompt so future bets start with a clean record

Setup takes about 25 minutes the first time. After that it’s a few minutes when something changes or a doubt surfaces.

Two People Who Need This

Marcus runs a small SaaS business. Six months ago he pivoted from a consumer product to B2B, based on a set of beliefs about enterprise willingness to pay, sales cycle length and his team’s ability to close. Things are moving, but slowly. He second-guesses the pivot almost weekly.

Diane left a senior role at a large firm to join a 40-person company as Head of Strategy, trading title and salary for what she believed would be faster learning, more autonomy and a clearer path to the C-suite. Eight months in she’s not sure. The learning is real but the path feels murkier than expected.

Neither of them is in a crisis. Both are in the same trap: they can’t remember precisely what they believed when they decided, so every bad week feels like evidence they were wrong. The assumptions log doesn’t tell them whether they made the right call. It tells them whether their doubts are based on something that’s actually changed.

Prompt 1: Build the Assumptions Log Template

What it does: Generates a structured log format that an AI can read, compare against new evidence, and reason about over time.

When to use it: Once, at setup. This becomes the document you maintain and reference going forward.

The Prompt:

Create an assumptions log template for someone tracking the beliefs 
behind a major business or career decision.

Each assumption entry should capture:
- The assumption itself, stated as a plain belief 
  (e.g. "Enterprise buyers in this space will pay £500/month")
- The decision it underpinned
- When it was logged
- Current status: HOLDING, WEAKENED, or INVALIDATED
- Evidence that changed the status (leave blank at start)

Format requirements:
- Plain text, easy to paste and update
- One section per major decision or bet
- A summary line at the top of each section showing 
  how many assumptions are HOLDING / WEAKENED / INVALIDATED
- Simple enough that updating it takes under 5 minutes

Include two placeholder examples — one business bet, 
one career bet — to show the format in use.

How to use it:

1. Run the prompt and save the output as a document in your Claude Project, or paste it into a note you can access quickly.

2. The placeholder examples show you the format. Replace them with your own in the next step.

3. Every future prompt in this sequence references this document.

Example input: No additional input needed. Run as written.

What you’ll get: A clean log structure with a summary header per decision, individual assumption entries with status fields, and two worked examples showing what a live log looks like. Something like:

ASSUMPTIONS LOG
===============

DECISION: [Name of bet or decision]
Date decided: [DATE]
Status summary: 4 HOLDING / 1 WEAKENED / 0 INVALIDATED

Assumption 1: [The belief]
Decision it underpins: [What you chose based on this]
Logged: [DATE]
Status: HOLDING
Evidence: —

Assumption 2: [The belief]
Decision it underpins: [What you chose based on this]
Logged: [DATE]
Status: WEAKENED
Evidence: [What changed and when]

Pro tip: Keep the assumptions short and falsifiable. “The market is big enough” is too vague to update. “There are at least 5,000 businesses in the UK spending over £1k/month on this problem” is something that can be HOLDING or INVALIDATED based on actual evidence.

Prompt 2: Extract Assumptions From a Decision You’ve Already Made

What it does: Takes an existing decision and reverse-engineers the implicit beliefs that were underneath it, so you can log them even if you never wrote them down at the time.

When to use it: For any decision already in flight. Most people won’t be starting from scratch.

The Prompt:

I made a significant decision recently. I didn't explicitly log my 
assumptions at the time, but I want to reconstruct them now.

Here's the decision and my best recollection of the reasoning:
[DESCRIBE THE DECISION AND WHY YOU MADE IT — as much detail as you 
can remember, including what you were hoping for and what you were 
worried about]

Your job:
1. Identify the key assumptions I was implicitly making. Look for 
   beliefs about: the market or environment, other people's behaviour, 
   my own capabilities, timing, and what would happen if I was right.

2. State each assumption plainly, as a specific falsifiable belief.

3. For each one, ask me: does this still feel true, partially true, 
   or no longer true? I'll update the statuses myself, but flag 
   anything where you'd want more information before classifying it.

Format the output ready to paste into my assumptions log.

How to use it:

1. Write your description of the decision messily. Don’t structure it. The AI will do the extraction.

2. Answer the status questions honestly. This is where the value is. Not in the format, but in being forced to say “actually, I no longer believe that.”

3. Paste the output into your log document with statuses filled in.

Example input:

“Six months ago I pivoted my SaaS from B2C to B2B. My thinking was that consumers weren’t willing to pay enough and that businesses would value the workflow benefits more. I thought we could close deals in 4-6 weeks and that my existing network would get us the first 10 customers without needing a dedicated sales hire. I was also betting that our small team could handle the added complexity of enterprise support without burning out.”

What you’ll get: Six to eight explicit assumptions, pulled from what was implicit in the description. Something like: “Enterprise buyers in this category will pay a meaningful premium over consumer pricing” / “Initial sales cycles will be 4-6 weeks” / “Founder network is sufficient to generate the first 10 customers” / “The team can absorb enterprise support demands at current headcount.” Each one ready to be marked HOLDING, WEAKENED or INVALIDATED.

Pro tip: The assumptions you resist logging are usually the ones most worth logging. If you find yourself thinking “well, that one’s obvious,” write it down. Obvious assumptions are the ones that quietly invalidate without anyone noticing.

You now have a Brand Profile and a defined Audience Persona, the ‘Who’ and ‘To Whom’ of your business. But if you stop here, Claude will still default to its own robotic prose because it doesn’t have your specific DNA yet.

To turn these profiles into a high-converting output engine, you need the Execution Layer.

Paid subscribers get the remaining 6 prompts to finalize their Skills File:

• The Voice & Tone Extractor: Stop ‘prompting’ for style and start extracting it from your best work.

• The Platform Rulebook: Automated constraints for LinkedIn, Email, and Ads so you never have to fix a 600-word ‘short’ email again.

• The Self-Revision Checklist: A recursive loop that forces Claude to edit its own ‘AI-isms’ before you ever see a draft.

• The Master Template: A copy-paste Markdown file to set up your Claude Project in 60 seconds.

Upgrade to unlock the full system.

Read more

This is the default experience for most solo operators using AI on real work. Not because the tools are bad. There’s just no shared memory of where things stand.

The fix is a control room: a single living document that gives your AI an always-current picture of every open project. Open loops, next actions, blockers. Updated at the end of each session, read at the start of the next. Set it up once and every future AI conversation starts informed rather than from scratch.

What You’ll Get

By the end of this article you’ll have:

• A control room document you can paste into a Claude Project today

• A brain-dump prompt that populates it from your current messy reality

• An update prompt you run at the end of each session (takes under 3 minutes)

• A daily briefing prompt that turns the control room into a prioritised work list

• An unstick prompt for anything that’s been blocked too long

The whole setup takes about 30 minutes the first time. After that, maintenance is a few minutes a day.

The Scenario

Meet Priya. She’s a solo brand consultant with five active projects: a client rebrand that’s 60% done and waiting on client feedback, a course she’s been building for four months, two proposals sitting in her drafts folder that need to go out this week, and a pricing restructure she’s been “thinking about” for six weeks.

She uses Claude regularly. But every session, she starts over. The AI has no idea the rebrand is stalled, that one proposal is almost ready and the other needs a rethink, or that the pricing thing is stressing her out more than any of the actual client work.

Her AI is smart. It just doesn’t know where she is.

That changes today.

Prompt 1: Build the Control Room Template

What it does: Generates a structured control room document formatted so an AI can read it, reason about it, and act on it. Not just store it.

When to use it: Once, at setup. This becomes the master document that lives in your Claude Project.

The Prompt:

Create a control room document template for a solo operator managing 
multiple projects simultaneously. 

The document should track:
- Open loops (things started but not finished, waiting on something, 
  or needing a decision)
- Next actions (the single most important next step for each project)
- Blockers (what's stopping progress and why)

Format requirements:
- Plain text, no complex markdown
- Each project gets its own section
- Status labels should be simple: ACTIVE, WAITING, BLOCKED, PARKED
- Include a "last updated" field at the top
- Leave a section for a weekly focus (the 1-2 things that matter most 
  this week regardless of what else is open)

The document should be readable by an AI in 30 seconds and give a 
complete picture of where everything stands. Include placeholder 
projects to show the format.

How to use it:

1. Run this prompt and save the output as a document in your Claude Project (paste it into the Project’s system prompt or attach it as a file).

2. Replace the placeholder projects with your real ones in the next step.

3. This document is what you’ll update and reference for every session going forward.

Example input: No additional input needed. Run the prompt as written.

What you’ll get: A clean, structured template with 3-4 placeholder projects showing how the format works. Something like:

CONTROL ROOM — Last updated: [DATE]
Weekly focus: [TOP 1-2 PRIORITIES THIS WEEK]

---
PROJECT: [Name]
Status: ACTIVE / WAITING / BLOCKED / PARKED
Open loop: [What's unfinished or unresolved]
Next action: [Single most important next step]
Blocker: [What's in the way, if anything]
Notes: [Anything the AI needs to know]

Pro tip: Keep the format simple on purpose. Elaborate templates don’t get maintained. If updating it feels like work, you’ll stop doing it.

Prompt 2: Populate It From Your Real Situation

What it does: Takes a messy brain-dump of your current projects and sorts it into control room format, without you having to do the organising manually.

When to use it: Right after creating the template. This is the prompt that actually gets the system running.

The Prompt:

I'm going to give you a brain-dump of everything currently on my plate. 
Your job is to sort this into my control room format.

Here's the format I'm using:
[PASTE YOUR CONTROL ROOM TEMPLATE]

Here's everything that's open right now — projects, half-finished tasks, 
things I'm waiting on, things I keep putting off, anything that has a 
next step I haven't taken:

[PASTE YOUR BRAIN-DUMP — write it messily, don't organise it first]

For each item:
- Assign the right status (ACTIVE, WAITING, BLOCKED, PARKED)
- Identify the single most important next action
- Flag anything that looks like a real blocker vs just procrastination
- Ask me if anything is unclear rather than guessing

Give me back the completed control room document, ready to paste.

How to use it:

1. Write your brain-dump fast. Don’t edit it, don’t organise it. Fragments are fine. “proposal for Marcus, not sent, needs the pricing section” is enough.

2. The AI will ask clarifying questions if something is ambiguous. Answer them briefly.

3. Paste the output back into your Project document, replacing the placeholder.

Example input:

“Rebrand for Holloway, waiting on their logo files since last Thursday. Course outline done but module 3 is a mess. Two proposals in drafts. One for a fintech client that just needs a proofread, one for a retail client I’m not sure about the scope. Pricing page on my site is wrong, been meaning to fix it. Also need to follow up with Sasha about the September project.”

What you’ll get: A fully formatted control room with each item correctly categorised, next actions identified, and at least one or two “is this blocked or just avoided?” questions back at you.

Pro tip: The AI will often flag things you’ve mentally filed as “active” that are actually blocked. That reclassification alone tends to be clarifying.

Your ‘Control Room’ is now populated. For the first time, your AI actually understands the mess on your plate.

But a map is only useful if you know how to navigate it. Without a daily ritual and a way to handle the ‘Stuck’ projects, this document will be out-of-date and useless by Friday morning.

Paid subscribers get the ‘Operating System’ that keeps this room running on autopilot:

• Prompt 3: The Daily Briefing. A 60-second prompt that tells you exactly what to touch today (and what to ignore) based on your actual hours available.

• Prompt 4: The 3-Minute Wrap-Up. The update loop that ensures your next AI session starts with 100% accurate context.

• Prompt 5: The ‘Unstick’ Engine. A specialized diagnostic tool for the projects you’ve been avoiding for weeks.

• The Master Template: A copy-paste Markdown file you can pin to your Claude Project in seconds.

Stop starting every AI session from zero. Upgrade to lock in your ‘Shared Memory’ system.

Read more

There’s a better way to use these tools. A single five-prompt sequence, build, challenge, destroy, rebuild, decide, will put any idea through more scrutiny than a week of back-and-forth with a colleague. You end up either genuinely confident in your position or convinced you need to change it. Either outcome is useful.

What You’ll Get

By the end of this sequence you’ll have:

• A steel-manned version of your idea (stronger than you started with)

• The three most credible objections, fully developed

• A genuine attempt to demolish the whole thing

• A rebuilt, tighter version that accounts for the weaknesses

• A clear-eyed recommendation you can act on

The whole process takes about 20 minutes. You can run it on a business decision, a strategic opinion, a contrarian take you’re thinking of publishing, or an argument you keep having with someone.

The Real-World Scenario

Say you’re an entrepreneur and you’ve landed on a belief: “Hiring generalists is better than specialists for early-stage companies.”

You’ve argued this to your co-founder twice. You’ve half-written a LinkedIn post about it. But you’re not fully sure it holds up.

Run it through this sequence and find out.

How the Sequence Works

Each prompt does one job. Don’t skip ahead, and don’t combine them. The value comes from doing the stages in order. The output from each step becomes part of the input for the next.

Prompt 1: Build the Best Version of the Idea

What it does: Forces the model to construct the strongest possible case for your position before anyone attacks it.

When to use it: At the start, with whatever rough version of the idea you have. Don’t polish it first.

The Prompt:

I have a position I want to test rigorously. Here it is in rough form:

[PASTE YOUR IDEA IN 1-3 SENTENCES]

Your job right now is to build the best possible version of this argument.

Assume it is correct. Find the strongest evidence, the most compelling logic,

and the most persuasive framing. Give me the steel-manned case — the version

I’d be proud to defend publicly.

Write it as a clear, structured argument of around 300 words.

How to use it:

1. Paste your idea in raw, unpolished form. Don’t pre-justify it.

2. Read the output and note anything that surprises you, ideas you hadn’t articulated yourself.

3. Save this output. You’ll reference it in Prompt 3.

Example input:

“Hiring generalists is better than specialists for early-stage companies.”

What you’ll get: A 300-word argument covering adaptability, resource constraints, the cost of over-specialisation, and why broad skills compound faster in a scrappy environment. Probably better-argued than your own version.

Pro tip: If the model’s steel-man surprises you with a point you’d never considered, that’s gold. It means there’s a stronger version of your idea than you’ve been defending. Use it.

Prompt 2: Find the Strongest Objections

What it does: Generates the three most credible counterarguments, written by someone who genuinely disagrees with you.

When to use it: Immediately after Prompt 1, before you’ve had time to feel good about the steel-man.

The Prompt:

Now switch sides completely.

Here is the argument you just helped me build:

[PASTE PROMPT 1 OUTPUT]

Your job is to be a sharp, well-informed critic who finds this argument

genuinely flawed. Identify the three strongest objections. For each one:

- State the objection clearly in one sentence

- Develop it in 2-3 sentences with specific evidence or logic

- Explain why it isn’t easily dismissed

Don’t steelman my position. Find the real cracks.

How to use it:

1. Paste the Prompt 1 output directly.

2. Read each objection and honestly note: “Did I know this? Is it actually a problem?”

3. Mark any objection that you can’t immediately answer.

Example input: The steel-manned generalist argument from Prompt 1.

What you’ll get: Three developed objections, probably something like: specialists can do critical technical work generalists can’t, generalists plateau once the company scales, and in competitive hiring markets you can’t attract strong specialists later if you diluted your culture early.

Pro tip: The objection that stings most is usually the most important one. Notice your emotional reaction, that’s diagnostic.

You now have the best possible version of your idea and a cold, hard look at the three biggest reasons it might fail. Most people stop here; they either let their ego ignore the risks or they lose confidence and abandon the idea entirely.

Paid subscribers get the ‘Stress Test’ and the ‘Phoenix Rebuild’ to ensure their ideas actually survive the real world:

• Prompt 3: The Demolition. A full adversarial attack to see if your logic holds up under professional fire. You need to know if it breaks before you ship it.

• Prompt 4: The Phoenix Rebuild. How to synthesize the criticism into a tighter, more defensible position that accounts for every weakness we just found.

• Prompt 5: The Final Call. A ‘No-Hedging’ prompt that forces Claude to stop saying ‘it depends’ and give you a concrete 48-hour action plan.

• Bonus: The 1-Page Controversy Audit. My personal pre-flight checklist for any contrarian take or strategic shift.

Don’t just confirm what you already think. Upgrade to build ideas that actually stand up.

Read more

Most team leaders discover skill gaps at the worst possible moment.

The project is underway. The deadline is real. And someone on the team doesn’t have the capability you assumed they had.

By then, your options are limited: delay, hire a contractor at a premium, or ship something that isn’t good enough. None of those are where you want to be.

The frustrating part is that the gap was always there. You just didn’t have a clear picture of it.

This is a common problem in SME cross-functional teams. Leaders have a rough sense of what their people can do, built up from past projects and day-to-day observation. But that’s not the same as a clear, structured view of team capability against the actual demands of upcoming work.

When you don’t have that picture, you make three kinds of mistakes. You assign the wrong people to work they aren’t ready for. You invest in training that doesn’t connect to anything urgent. And you hire for the wrong roles, or delay hiring until a crisis forces the decision.

AI can help you build that picture systematically, before those mistakes happen.

Competency Mapping Against Project Demand

The approach here isn’t a performance review or an HR exercise. It’s a decision-making framework built around one core question: given the work your team is about to do, what capability does it need, and what capability does it actually have?

That question has four parts, each of which maps to a structured AI prompt.

• First, you need to know what your team can currently do, honestly and specifically, not just job titles and years of experience. That’s the competency map.

• Second, you need to understand what your upcoming projects actually require at the task level, not the headline level. That’s the project requirement analysis.

• Third, once you can see both sides of the equation, you need to decide which gaps matter most and in what order. That’s the training priority ranking.

• Fourth, some gaps can’t be closed by training in time. You need to know which ones require a hire, when, and what that hire should look like. That’s the hiring need identification.

Run these four prompts in sequence and you move from a vague sense of team capability to a concrete action plan.

The Problem With How Most Teams Do This

Most leaders approach skill gaps reactively. They notice a problem on a live project and respond to it. Or they run an annual performance cycle that produces a list of development areas with no clear connection to what the team is actually working on.

The other common failure is using AI incorrectly for this problem. Prompting an AI tool with “what skills does my team need?” produces generic output, a list of competencies that could apply to any team anywhere. It doesn’t help you.

The prompts below are structured differently. They ask you to provide specific context, your team, your projects, your constraints, so the AI can generate analysis that’s actually relevant to your situation. The AI isn’t making the decisions. It’s helping you see clearly so you can.

Quick Start Prompt

Use this prompt to get an immediate, high-level picture of where your team’s capability sits relative to your current priorities.

Team Skill Snapshot

I want to understand my team’s current capability against our upcoming priorities.

Team Overview: [Number of people, general roles or functions, rough tenure mix]

Upcoming Priorities: [List 3-5 projects or initiatives planned for the next quarter]

Current Concern: [What specific capability gap or project risk is already on your radar]

Please give me:

1. CAPABILITY QUESTIONS: What are the 5 most important questions I should be asking

about my team’s current skills, given these priorities?

2. RISK FLAGS: Based on what I’ve described, what are the most likely capability gaps

that could slow down or derail these priorities?

3. NEXT STEP: What’s the single most useful thing I should map or clarify first?

Keep responses specific to the context I’ve provided, not generic best practices.

This prompt won’t give you a complete picture, but it will tell you where to focus first. The four advanced prompts below take you the rest of the way.

Advanced Prompt Framework

These four prompts work in sequence. Each one builds on the output of the previous. Run them in order with your real team data.

Prompt 1: Competency Mapper

Purpose: Build a structured, honest map of what your team can currently do.

Competency Mapper

I need to build an accurate competency map for my team, not a list of job titles, but a realistic picture of actual current capabilities.

Team Composition: [List roles, approximate experience levels, and any relevant specialisations]

Recent Projects Completed: [List 3-5 recent projects and what each required]

Known Strengths: [What does this team do consistently well]

Suspected Weaknesses: [Where have you seen performance drop or projects slow down]

Please help me build a competency map that covers:

1. CORE COMPETENCIES: What capabilities does this team demonstrably have, based on

the work they’ve completed? Be specific, not generic.

2. COMPETENCY LEVELS: For each capability, suggest a simple rating framework

(beginner/developing/proficient/expert) and where this team likely sits based on available evidence.

3. HIDDEN GAPS: Based on the team composition and recent work, what capabilities are

probably underdeveloped but might not be obvious from the surface?

4. ASSUMED VS ACTUAL: What skills might this team be assumed to have (based on roles

or titles) that the evidence suggests may not be as strong as expected?

5. MAPPING QUESTIONS: What additional information should I gather from the team to

make this map more accurate?

Base your analysis on the specifics I’ve provided. Flag where you’re making reasonable inferences vs. drawing on stated facts.

SAMPLE INPUT

8-person cross-functional team, mix of operations, marketing, and product roles, average 3 years tenure, recent projects include a CRM migration, a campaign launch, and a customer onboarding redesign.

Once you have your Competency Map, you have a clear picture of what your team is. But a map is useless if you don’t know the terrain you’re about to cross.

To turn this map into a bulletproof execution plan, you need to bridge the gap between ‘what we know’ and ‘what the deadline demands.’

Paid subscribers get access to the three ‘Decision Engine’ prompts that complete this framework:

• The Project Requirement Analyzer: Breaks your Q3/Q4 goals into task-level “must-haves” so you aren’t guessing at capacity.

• The Training Priority Ranker: A logic-gate prompt that tells you exactly which skills can be taught in 8 weeks—and which ones can’t.

• The Hiring Need Identifier: A ‘Hire vs. Contractor’ calculator that builds the business case for new headcount before the crisis hits.

• The Full Case Study: A breakdown of how a 12-person ops team can use this exact sequence to save a failing compliance audit.

Upgrade to unlock the full Team Capability Framework and the Quarterly Skills Audit template below.

Read more

In this workshop:

1. Detailed Reference Guide, containing a concept overview, quick start method, 4 x prompts, real-world scenario, common mistakes, implementation framework, notes, and customisation.

2. Facilitators Guide, including sample email, detailed agenda and timings (can be adjusted), intro scripts for each section of the workshop, post-workshop follow-up, and more.

3. Participant Workbook, structured notes, to be completed during the workshop.

These documents should be viewed as a starting point. Amend as necessary for your specific need.

Downloadable Workshop Kit

Read more

Researchers at Microsoft and Carnegie Mellon University surveyed 319 of these people. They gathered 936 real-world examples of knowledge workers using generative AI at work. What they found, and I want you to sit with this for a moment, is that in roughly 40% of tasks, the workers applied no critical thinking whatsoever.

Zero. They read the machine’s answer and went: yes, that’ll do.

The researchers noted that mechanising routine tasks deprives users of the routine practice needed to keep their judgement sharp, leaving it “atrophied and unprepared” when anything difficult actually comes along.

Atrophied. That’s the word a Microsoft researcher chose. About people who work in offices. With computers. In 2025.

Natural born cyborgs

Before we get to the full horror of what this means, there’s a philosophical argument that keeps turning up in the academic literature on this subject, and it’s worth explaining because it reframes the whole thing in a way that is either reassuring or deeply not reassuring, depending on your disposition.

In 1998, Andy Clark and David Chalmers published a paper called “The Extended Mind.” Their point was that the boundary between what’s inside your head and what’s outside it is a lot blurrier than we like to think. They used the example of a person with Alzheimer’s who writes appointments in a notebook and checks it reliably. That notebook, in some meaningful sense, is doing some of the thinking. It’s not just a tool. Part of the cognitive process genuinely lives out there, on the page.

Clark has spent the decades since developing this idea, and in May 2025 he applied it directly to AI in a paper in Nature Communications. His argument’s that humans have always built hybrid thinking systems, ones that pull in non-biological resources, and that AI is just the latest and most powerful version of this. We are, he says, “natural-born cyborgs.”

I find this framing simultaneously correct and extremely easy to weaponise by people who want an intellectual-sounding reason to never question a chatbot again.

What happens when you build the hybrid badly

The Microsoft study is a detailed portrait of exactly that. The more confident a worker was that the AI could handle a task, the less thinking they did. The outputs got more homogenous across users. Everyone started producing subtly similar work because they were all drawing from the same machine and none of them were pushing back on it. The individual voice, the inconvenient angle, the thought that only you would have had: gone. Smoothed away by a system specifically designed to give you something fluent and acceptable, which isn’t the same thing as something true.

Research published in Frontiers in Artificial Intelligence gives this pattern a name. It’s called the “hollowed mind.” The idea is that when AI-generated answers are available instantly and effortlessly, users start bypassing the effortful thinking that actually builds understanding. The same paper identifies something it calls the “sovereignty trap,” which is where the AI’s air of confident authority nudges users into handing over their intellectual judgement, mistaking the ability to retrieve information for the ability to think about it.

The hollowed mind doesn’t arrive in one catastrophic moment. It accumulates across dozens of small surrenders: accepting a framing you didn’t choose, skipping the source because the summary seemed fine, letting the machine make a call you were perfectly capable of making yourself. I’m not pointing fingers here. I’ve done all of those things. I did some of them this morning.

The bit where it gets more complicated

Read more

The output isn’t bad. It’s just not theirs. Claude doesn’t know their clients, their voice, or the specific rules that make their copy convert. So it writes something technically competent and completely interchangeable, and the writer does the heavy lifting anyway.

There’s a fix. It’s called a skills file: a permanent context document you build once and load into Claude’s Project Instructions. After that, Claude starts every job already knowing your client’s brand, your preferred structure, your forbidden phrases, and your output standards.

8 prompts to build yours. About 20 minutes of setup. No coding required…

What a Skills File Actually Does

A skills file sits inside a Claude Project as the Project Instructions. Every conversation inside that Project starts with Claude having already read it.

For copywriters, that means no more pasting the brand guide every time. No more correcting Claude’s tone on the third draft. No more explaining that this client never uses exclamation marks or that this brief needs a CTA in the first 100 words.

You build one skills file per client (or per content type, if you prefer). Claude reads it. You brief the job. The first draft is closer to publishable.

Prompt #1: Client Brand Profile Builder

What it does: Creates the core brand context section of your skills file so Claude understands the client before writing a word.

When to use it: First, for every new client. This is the section that stops Claude from writing generic copy that ignores who the brand actually is.

The Prompt:

I'm building a Claude skills file for a client — a permanent context document 
I'll paste into Claude's Project Instructions so I stop re-briefing it every session.

Help me build the "Brand Profile" section. Ask me the following questions one 
at a time, then compile my answers into a clean, structured section ready to paste.

Questions to ask:
1. What's the client's company name and what do they sell or do?
2. Who is their target customer — be specific about demographics, job title, 
   life stage, or whatever's most relevant?
3. What's the brand's personality in three words — and what are three words 
   it should never be?
4. What does this brand do better than its competitors — honestly?
5. What's the one thing this brand should never say or imply in its copy?
6. Any specific terminology, product names, or industry language Claude 
   should always or never use?

Format my answers under the header: ## Brand Profile — [CLIENT NAME]
Keep it factual and under 200 words. Write it as instructions for Claude, 
not as a brand description.

How to use it:

1. Paste the prompt and answer each question when Claude asks

2. Review the output and correct anything that doesn’t match the actual brief

3. Save the section to a new document called [clientname]-skills-file.md

Example input:

Company: Harbour Financial Planning. They do retirement planning for Australians aged 55-70. Target customer: people 3-10 years from retirement, usually dual-income couples, comfortable but not wealthy, worried they’ve left it too late. Brand personality: reassuring, plain-speaking, knowledgeable. Never: alarmist, jargon-heavy, salesy. Better than competitors at making complex super rules understandable. Never imply clients have made financial mistakes. Always use “super” not “superannuation” in body copy.

What you’ll get: A brand profile section Claude references every time it writes for this client: no re-briefing, no tone drift across a long project.

Pro tip: Add the brand’s tagline and one example of copy the client has approved and loved. Claude uses both as style anchors without you having to explain what “on-brand” means.

Prompt #2: Audience Persona Builder

What it does: Builds the reader persona Claude will write to, not a demographic summary, but a psychographic sketch that shifts how Claude calibrates tone, vocabulary and emphasis.

When to use it: After the brand profile. This is what stops Claude from writing for a theoretical reader instead of the actual one.

The Prompt:

I need to add an "Audience Persona" section to my Claude skills file for [CLIENT NAME].

I'll describe the primary reader this copy is written for. Based on my description, 
write a persona that tells Claude:

- Who this person is (role, life stage, or situation — whatever's most relevant)
- What they want (their goal when engaging with this content)
- What they're afraid of (their hesitation, doubt, or objection)
- How they talk (vocabulary level, formality, industry familiarity)
- What makes them click or convert (what actually moves them)
- What makes them leave (what kills the copy for them immediately)

Here's my description of the primary reader:
[DESCRIBE YOUR CLIENT'S ACTUAL TARGET READER IN 3-5 SENTENCES]

Format the output under the header: ## Primary Reader — [CLIENT NAME]
Write it as instructions for Claude ("Write for a reader who..."), 
not as a persona card. Keep it under 150 words.

How to use it:

1. Replace the placeholder with your honest read of who actually buys from this client

2. Review Claude’s persona and adjust any language that feels off

3. Add the section to your skills file

Example input:

Primary reader: Marketing managers at mid-size B2B SaaS companies, typically 28-38, responsible for pipeline but not the final budget decision. Smart and sceptical — they’ve been oversold to a hundred times and they know it. They want proof, not promises. They skim first and only read if the headline earns it. Nothing kills them faster than vendor-speak or vague ROI claims without numbers.

What you’ll get: A reader definition that shifts Claude’s defaults, harder evidence when they’re sceptical, simpler language when they’re not insiders, shorter paragraphs when they skim.

Pro tip: Add a “what this reader has already tried” line. Knowing what hasn’t worked for them helps Claude avoid writing copy that sounds like a solution they’ve already rejected.

You now have a Brand Profile and a defined Audience Persona; the ‘Who’ and the ‘To Whom.’ If you stop here, Claude will understand the world you’re writing in, but it will still use its own generic ‘AI voice’ to describe it.

To turn these profiles into a high-speed, copy-paste production engine, you need the Execution Layer.

Paid subscribers get the remaining 6 prompts to finalize their Skills File:

• Prompt #3: The Voice & Tone Extractor. The single most important prompt in this sequence. It stops Claude from ‘guessing’ and forces it to match your client’s exact rhythm and vocabulary.

• The Multi-Channel Ruleset. Platform-specific constraints for LinkedIn, Email, and Ads so you never have to manually fix a ‘too-long’ post again.

• The Brief Translator. How to give Claude 2-line ‘lazy’ briefs and get 1,000-word on-brand drafts.

• The Revision Instruction Set. A self-editing loop that catches ‘AI-isms’ and passive voice before you ever see the first draft.

• The Master Assembler. One prompt to package all 8 sections into a perfectly formatted Markdown file for your Claude Project.

Stop billing the time you didn’t save. Upgrade to unlock the full ‘Skills File’ system and the 10-minute Quick-Start Template.

Read more

Most teams spend their strategic planning sessions debating the present. They argue about what competitors are doing now, what customers want today, and what the market looks like this quarter. By the time they act on those insights, the landscape has shifted.

Futures Thinking is the discipline of systematically examining signals, trends, and second-order consequences to identify the questions your business will need to answer in 12, 24, or 36 months. It doesn’t try to predict the future with certainty. It maps the territory of possibilities so your team is not constantly caught off guard.

The thinking model has been used for decades by scenario planners, intelligence analysts, and corporate strategists. The core process involves four disciplines: scanning for weak signals at the edges of your industry, identifying drivers of change that cut across multiple sectors, mapping the implications those drivers create, and then pressure-testing your current strategy against a range of plausible futures.

Used without structure, it produces interesting but non-actionable speculation. Used with structured AI prompts, it becomes one of the most powerful strategic tools available to any SME team.

The Problem: Why Most Teams Get Future Thinking Wrong

The most common mistake is treating future foresight as a prediction exercise. Teams ask AI tools “what will happen in our industry in three years?” and accept whatever confident-sounding answer comes back. They aren’t getting foresight. They’re getting pattern-matched guesswork dressed up as strategy.

The second mistake is the opposite: paralysis. Teams surface so many possible futures that they cannot prioritise, and the exercise dissolves into an interesting conversation with no decisions attached to it.

The third mistake, and perhaps the most damaging for SMEs, is scanning the wrong horizon. Teams focus on macro trends, global shifts, and industry-wide disruptions when the most strategically relevant signals for their business are sitting at the intersection of two or three specific trends that nobody else is connecting yet.

Structured AI prompting solves all three problems. Instead of asking AI to predict, you use it to systematically surface questions, map assumptions, and stress-test your strategy against specific scenarios. AI becomes a rigorous thinking partner for structured foresight, not an oracle.

The Quick Start Prompt: Surface Your Strategic Blind Spots

Use this immediately with any conversational AI tool (ChatGPT, Claude, Google Gemini).

I want to identify the strategic questions my business will need to answer in the next 
18 to 24 months, but may not be asking yet.

My business context: [Describe your industry, business model, team size, and current 
strategic focus]

Current priorities: [What are you focused on right now, and what assumptions underlie 
those priorities]

Please help me do the following:

1. EMERGING QUESTIONS: What are the five most important questions my business 
will need to answer in the next 18 to 24 months, based on trends affecting my 
industry and adjacent sectors?

2. SIGNAL SOURCES: For each question, what early indicators exist today that suggest 
this question is becoming more urgent?

3. ASSUMPTION GAPS: What assumptions am I currently making about my customers, 
market, or competitive landscape that these trends could invalidate?

4. FIRST MOVES: For each question, what is the lowest-cost action I could take now 
to begin gathering better information?

Be specific to my business context. Avoid generic trend lists. Focus on questions 
that are material to a business of my size and stage.

This prompt alone will surface more actionable strategic insight than most quarterly planning sessions. The section below takes the framework significantly further.

THE FUTURE FORESIGHT FRAMEWORK

The four prompts below build on each other sequentially. Work through them in order for a complete foresight session, or use each one independently as your situation requires.

Read more