How do I structure a prompt to get a numbered list of actionable steps, not an essay?

The "act as if" trick usually works. Try framing it like "Act as a senior technical writer preparing a runbook. Provide only a numbered, sequential list of steps to migrate a Jira project."

I've found if you leave any room for interpretation, most assistants default to their verbose, essayist mode. You have to explicitly strip out their natural inclinations.

I've had some luck with that approach too, but I find it still depends on the assistant's core training. "Act as if" sometimes just adds an extra layer of preamble where it thanks you for the role assignment before launching into the essay.

What works for me is stacking explicit constraints. Something like: "Provide only a numbered list of steps. No explanations. No introductory paragraph. No concluding summary. Start directly with step 1."

It's a bit hostile, but that's the point. You're basically pasting a linting rule into the prompt.

You're hitting on the core problem: "concisely" and "bullet list" are still too vague. The assistant's training prioritizes being thorough, which means caveats come first.

I treat the prompt like a Jenkins pipeline directive. You need strict, unambiguous formatting rules. I use a template:

```
Task: [What you want done]
Format: Strictly a numbered list, 1. 2. 3.
Scope: [Optional, to limit steps]
Start now.
```

Example: "Task: Migrate a Jira project. Format: Strictly a numbered list, 1. 2. 3. Scope: Pre-migration checklist and data export. Start now."

The "Start now." is the key command. It cuts off the preamble reflex. This works across GitHub Actions, GitLab CI, and most chatbots I've tried.

That pipeline directive approach is clever. The "Start now" feels like a hard break in the context window, which probably explains why it works.

I wonder if it scales down to simpler assistants, like those in no-code platforms. Sometimes you're stuck with a basic chat widget and can't feed it a full template. I've tried a stripped-down version, just "Steps only, numbered, start now," and it's hit or miss.

You're right, the "give me a bullet list" ask is too weak. It's treated as a suggestion, not a command.

I treat it like writing an alert rule. Be explicit and atomic. My go-to is:

```
Numbered steps only. No preamble. No summary.
1.
```

Paste that, then your question on the next line. It's a boundary the model usually respects.

That "boundary" idea with the empty `1.` is a good trick. I'm going to steal it for my Terraform prompts.

I do wonder, though, does it sometimes cut out *too* much? Like if a step is inherently dangerous and the assistant leaves out the "make sure your backups are current" note because it's not a numbered step? I guess you'd have to build that warning into a step itself.

The trigger I've found most reliable is to explicitly forbid what you don't want. Your "wall of text" problem happens because assistants are trained to elaborate. So instead of asking for a list, start by saying "Do not provide explanations or background. Provide only a numbered list of steps." That usually cuts the preamble off at the knees.

It's a simple inversion, but framing it as a restriction works better than phrasing it as a request.

Your core issue is that "list steps concisely" still lives within the assistant's natural language framework, where being thorough is rewarded. I model this as a data mapping problem: you need to coerce the unstructured text output into a strict schema.

The most effective prompt structure I've found for this is a two-part instruction that first defines the forbidden output formats, then specifies the required format. For your example, I'd use:

```
Do not provide explanations, background, or caveats. Output must be a strictly numbered list starting at 1. Begin immediately with the first step.
How do I migrate a Jira project?
```

The key is placing the constraints *before* the query. This primes the model to apply a filter to its response generation. The "Begin immediately" acts as a final, non-negotiable instruction to skip any introductory sentence. It's less about a specific trigger word and more about defining a rigid output template it must populate.

You're overcomplicating it. That prompt is just as brittle as the others. I've tried the "define forbidden output first" approach with Slack's AI features and it works until it doesn't. The model will still find a way to preface the list with "Sure, I can help with that. Here is a strictly numbered list:".

The "begin immediately" command is weak. It's not a final instruction, it's just another word in the sentence it's ignoring.

Placement doesn't matter. These things don't "prime" like you think. They're just parsing tokens for intent. Your prompt is still asking for a thing, and their core training is to explain the thing first.

That's a solid tactic, and I've had good luck with it for CRM migration checklists. The inversion works because you're directly countering the default training to be helpful by being conversational.

But I've noticed a quirk with it on platforms like HubSpot's AI tools: if you ask a complex question about data deduplication rules, the "no background" rule can sometimes strip out a necessary qualifier, like whether a step applies to custom objects or not. You have to bake the "why" into the step itself, like "1. Export contacts, ensuring you include custom field data." It becomes part of the instruction.

That's a really good point about having to bake the "why" into the step itself. It reminds me of writing procedures for my small business. If I just wrote "reconcile the bank statement" for my bookkeeper, they'd have questions. I have to write it as "1. Reconcile the bank statement in QuickBooks, matching each transaction to your recorded invoices and expenses."

It forces you to be more precise, which is probably better in the long run, even if it makes the prompt a little longer. Have you found that being super specific in the step description helps the AI stick to the format, or does it sometimes make it *more* likely to wander off and explain that specific point?

You're hitting on a core problem with instruction-following in these models. "Give me a bullet list" fails because it's still a request within a conversational frame.

Based on my testing, the most reliable structure is a direct format command followed by an explicit stop. For your example:

Format: Numbered list.
How do I migrate a Jira project?
Stop.

The "Format:" prefix treats it as a system-level instruction rather than conversational text. The "Stop." after the question creates a hard boundary that often prevents the model from appending a summary or caveats. This method has proven more consistent than asking for conciseness.

Yeah, the "act as a" prompt is my go-to for this too, especially for runbooks. It helps set a specific context for the model, like telling it the audience and purpose.

But I've run into a small snag: sometimes it still gives me a long intro before the list, like "As a senior technical writer, I will now outline the steps..." So I've started combining it with a direct "No preamble" command, which usually seals the deal.

Does anyone find that the specific role you choose changes the tone of the steps? Like, does "act as a security auditor" give more cautious steps than a "systems engineer"?

Your problem is framing it as a request. The model is trained to fulfill requests with "helpful" context.

Treat it as a format directive. Specify the output structure first, then the task. This works consistently across models for runbooks.

```
Output format: 1. Action. 2. Action.
Task: Migrate a Jira project.
```

If you need a caveat, embed it in the step: "1. (Prerequisite: Ensure backups exist) Export project data."