AI Prompt Symbols: Organize Instructions with Headings and Delimiters

Should you use a hash sign, brackets or other symbols when writing an AI prompt?

Symbols can help separate instructions into sections or show where source material begins and ends.

They do not guarantee a correct answer, and the same symbol can play different roles in different contexts or services.

This guide uses practical examples to explain why you might use a symbol, how to type it, and what to check before relying on the result.

Decide what you need to separate first

A prompt is a message telling an AI what you want it to do.

For a short request, you may not need special symbols at all.

The request has one clear task, so you can try it as written.

When you add source material and conditions, however, it becomes harder for a person reviewing the prompt to see where the request ends and the material begins.

Separate the request from the source

Imagine the organizer of a book club at a local library wants to turn staff notes into a message for participants.

The organizer wants to write a notice for first-time participants.

One way to make each section's role easier to see is to add headings:

Here, # marks a heading.

The important point is to separate the roles of the request, conditions and source, not to add symbols for their own sake.

The notes do not give a year or the library's address, so the organizer must confirm them before sending a real notice.

Symbols cannot supply missing facts

A heading does not tell the AI an address that is absent from the notes.

Nor does organizing the prompt guarantee that every condition will be followed.

Before using the answer, compare details such as the fee and time with the original notes.

Use hash signs and hyphens for headings and lists

The symbols # and - can help organize sections and items.

They are used in Markdown, a way to write text with headings and lists.

Services display them differently; even where they are not rendered as formatting, they can serve as visible separators in your request.

Give each section a heading

The example places a space after # before the heading text.

A heading helps you review the roles of the sections, but the heading alone does not supply its contents.

If the conditions section is empty, it does not tell the AI what to preserve.

List parallel items with hyphens

Place a space after each -.

Here the four items are all details to include, not alternatives from which to choose one.

Check the finished answer against the notes; a list does not ensure each detail was extracted correctly.

Use numbers when order matters

This request sets out an order: extract information, draft the notice, then identify gaps.

Check whether the result follows that structure and whether the extracted information matches the source.

Use quotation marks to identify a short passage

Quotation marks can show which text is the source of a request.

Here we use the double-quote character " that you can type in an input field.

Pass a single sentence

Suppose you want to rephrase this sentence from the book-club notes:

You can put the target passage inside quotation marks:

The quotation marks identify what should be rewritten.

You still need to check that the answer has not changed the fee or registration requirement.

When the source contains the same symbol

If the passage itself contains quotation marks, it may be harder to see which marks define the outside boundary.

Rather than nesting the same symbol without explanation, consider headings or the named tags described below.

If a service or integration requires a particular format, follow its documentation.

Mark the beginning and end of longer source material

For multi-line material, showing the boundaries can make the prompt easier for you to review.

You can use a divider or named tags; there is no single required method.

Use a divider

Here --- is a visible boundary marker.

If the source itself includes the same divider, choose a different boundary so it is clear where the material ends.

Use named tags

<notes> marks the start and </notes> marks the end.

The name notes identifies the role of the material in this example.

Using the same name at both ends helps a person follow the boundary.

Tags do not guarantee that the contents are safe or that an instruction inside them will be ignored.

Don't confuse a source's instructions with your own request

Text received from an outside source may contain an instruction unrelated to your task.

For example, an event note could contain this sentence:

That sentence is not event information needed for a participant notice.

Tell the AI to treat the material as source text, and check that irrelevant instructions have not affected the result.

A delimiter by itself is not a security safeguard.

Check the service's settings and data access permissions, and keep a human in control of important actions.

Keep two sources from getting mixed together

Suppose you need separate notices for events at two venues on the same day.

The date is not yet known for either venue.

If the notes run together, a person reviewing them could miss which time and fee belong to which venue.

Here is an illustrative response written by the editors:

Headings let you compare each venue's answer with its own notes.

They do not guarantee that the AI will keep the details together.

Before sending the notices, check each venue, time and fee as a set, and confirm the missing date.

When the source already has headings

If the source itself contains headings such as # Venue A, using similar headings outside it may make the source boundary harder to see.

You can enclose the complete source in a differently named tag while retaining the venue headings within it.

The goal is a boundary that a person can follow, not a stack of symbols.

Use matching start and end tag names, and make sure the same closing marker does not already occur in the source.

Use code fences to show text or code literally

Sometimes the text you pass includes symbols or code that you want to show as a unit.

Markdown supports code fences: three backticks on a line before and after the text.

This example shows what you might enter:

Extract only the product number from the following text without changing it.

```
Product number: A-104
```

The outer visual block is for displaying the example; the lines of three backticks around the product number are part of the sample input.

Rendering environments can handle nested fences differently, so check the format and number of backticks where you enter the prompt.

The target text is:

The expected value is A-104, but compare the AI's answer with the actual number.

A code fence indicates a text boundary; it does not guarantee that a program will run correctly.

Use square brackets as placeholders

For a reusable prompt, square brackets can mark details that must be replaced each time.

Here [audience] and [source] are placeholders, not facts.

A completed request might read:

Before sending a template, check that placeholders have been replaced and no old source details remain.

Square brackets are not mandatory; use another marker if your team or tool has a different convention.

Use JSON when a system needs a defined data format

If an answer will be passed to a program, you might request JSON, a format that represents named fields and values.

For example, extract a date and fee from the book-club notes:

The following is an illustrative expected shape:

{"date":"November 14","fee":"free"}

The braces {} enclose the object; "date" and "fee" are field names.

A colon : separates each name from its value, and a comma , separates the fields.

JSON has defined syntax, including double quotes for strings.

A similar-looking answer may still be invalid

An answer that resembles JSON can fail to parse if it has missing brackets or extra text.

The receiving program should check that it can parse the JSON and that required fields are present.

Some services offer structured-output features, but availability and configuration differ by service, model and API.

Consult the provider's current documentation for the feature you use.

Even valid JSON does not prove the date or fee is correct; compare the values with the source separately.

When a symbol displays literally

Depending on the service, a typed symbol may remain visible rather than rendering as a heading or list.

Check whether the request contains the information you need, even if the appearance differs from what you expected.

A hash sign is not displayed as a heading

Seeing # Conditions literally after sending it does not by itself show that the AI ignored the conditions.

Check the actual response against the source for the fee and required items.

Display and answer content are separate checks.

Some services provide display settings, but the available controls vary.

List lines run together

If line breaks are hard to see, check the submitted message where the service allows it and inspect the answer to see whether the conditions were addressed.

Consult the service's instructions if you cannot work out how to enter a line break.

You can also state conditions in a sentence:

The goal is to communicate what needs to be included, not to use a particular symbol.

Resolve conflicts between instructions and sources first

Clear sections do not resolve a disagreement between the facts written in them.

The condition and the notes give different times.

Before asking for a notice, confirm the correct time with the organizer.

The two lines do not tell us whether the notes are outdated or the condition is wrong.

If the organizer confirms 3 p.m., update the request and source accordingly:

This is only a short illustration of resolving the conflict.

A real participant notice also needs the date, location and other details absent from this shortened note.

Check before and after choosing symbols

Before sending, check that each heading contains the right material and that each boundary is closed.

For tags, make sure a pair such as <notes> and </notes> uses the same name.

For a template, verify that placeholders such as [source] have been replaced with the current information.

Check your organization's rules and service settings before entering private or confidential source material.

After receiving the answer, check both whether it fits your purpose and whether important facts match the source.

If another program needs JSON, also test whether the format can be parsed.

Content accuracy and format validity are separate checks.

When a source contains the same closing tag

If the material itself contains </notes>, enclosing it in another pair of notes tags may make the boundary confusing to a person reading it.

One option is to use a different name for the outer boundary:

The outer source_text tags match, while </notes> is part of the source text.

This is not a guarantee that the AI will respect the boundary.

If another tool parses strict XML, follow that tool's syntax and escaping rules; this chat example is not guaranteed to be valid input for an arbitrary XML processor.

Check whether literal < and > characters are accepted and confirm what the inner and outer markers represent before copying an example into an integration.

Which symbols should you choose?

You don't need to memorize every symbol before writing a prompt.

Choose based on what needs separating and what you need to check later:

• Headings: Separate the request, conditions and source.
• Lists: Present parallel conditions or an ordered sequence.
• Dividers and tags: Mark the start and end of source material.
• Code fences: Show code or symbol-containing text as a unit.
• Square brackets: Mark places to replace in a template.
• JSON: Provide a defined format for a program to receive.

If the information itself is missing, confirming it comes before adding more punctuation.

For a notice or business decision, check the source, current information and the receiving system's requirements before using the result.