AI Prompt Engineering · Lesson

Requesting Lists and Bullet Points

Ask AI for numbered or bulleted lists with specific item counts.

Requesting Lists and Bullet Points is a free AI Prompt Engineering lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the AI Prompt Engineering learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Why Lists Work Well with AI

Lists are one of the clearest output formats to request from an AI. They are unambiguous, scannable, and easy to verify — you can immediately count whether you got the number of items you asked for.

Knowing the exact syntax for list requests helps you get consistently formatted output without follow-up corrections.

Basic List Requests

The most common list request patterns:

'List 5 ways to...'
'Give me 10 bullet points about...'
'Name 7 examples of...'
'Provide 3 reasons why...'

Always specify the exact count. Saying 'list some ways' produces a variable number of items — sometimes 3, sometimes 12. A number eliminates that variance.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=300,
    messages=[{
        'role': 'user',
        'content': 'List exactly 5 ways a developer can improve Python code performance. Each item: one sentence only.'
    }]
)
print(response.content[0].text)

Bullet Point Requests

When you want bullet point formatting specifically (rather than numbered lists), say so explicitly. Markdown bullets (- or •) are rendered in most chat UIs but not all environments.

'Give me 8 bullet points on...'
'Create a bulleted list of...'
'Output as bullet points, one per line...'

Add 'each bullet: max X words' to control density.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{
        'role': 'user',
        'content': (
            'Create a bulleted list of 8 best practices for writing REST APIs. '
            'Format: each bullet starts with a bold action verb. '
            'Each bullet: max 15 words. No sub-bullets.'
        )
    }]
)
print(response.choices[0].message.content)

Numbered Lists and Steps

Numbered lists are best for sequential content where order matters:

Step-by-step instructions
Ranked options (most to least recommended)
Prioritized task lists
Ordered troubleshooting steps

Use: 'Number each step...', 'List in order from most to least...', 'Give me 6 numbered steps to...'

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=400,
    messages=[{
        'role': 'user',
        'content': (
            'Give me 6 numbered steps to deploy a Python FastAPI app to AWS EC2. '
            'Order: from initial setup to app accessible via browser. '
            'Each step: 1-2 sentences + the specific command(s) to run. '
            'Assume a fresh Ubuntu 22.04 server.'
        )
    }]
)
print(response.content[0].text)

Checklists

Checklists are a specific list subtype — items meant to be checked off. They work especially well for:

Code review checklists
Launch readiness checklists
Security audit checklists
Onboarding checklists

Request: 'Create a checklist of...' or 'Generate a pre-launch checklist for...' The model will output items in a format with - [ ] checkboxes (markdown standard).

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{
        'role': 'user',
        'content': (
            'Create a pre-production launch checklist for a Python web API. '
            'Format: markdown checkboxes (- [ ] item). '
            'Group into sections: Security, Performance, Monitoring, Documentation. '
            '4 items per section. Each item: specific and actionable in under 12 words.'
        )
    }]
)
print(response.choices[0].message.content)

Controlling Item Length and Density

List quality improves dramatically when you specify how much detail each item should contain:

'One sentence per item' — tight, scannable
'Two sentences: first describes what, second explains why' — structured detail
'Item title + 1-line description' — header + explanation
'Max 10 words per item' — force extreme conciseness

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

# Two-sentence structure per list item
response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=400,
    messages=[{
        'role': 'user',
        'content': (
            'List 5 common Python performance bottlenecks. '
            'For each item, use exactly 2 sentences: '
            'Sentence 1: describe the bottleneck. '
            'Sentence 2: state the fix in one specific action.'
        )
    }]
)
print(response.content[0].text)

Labeled and Categorized Lists

Adding labels to list items creates categorized or tagged lists that are easier to scan and use:

'Label each item as EASY, MEDIUM, or HARD'
'Tag each suggestion with the relevant team: [FRONTEND] [BACKEND] [DEVOPS]'
'Mark each with the expected time investment: (5 min) (2 hr) (1 week)'

Labels transform a flat list into an actionable, filterable resource.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{
        'role': 'user',
        'content': (
            'List 8 ways to reduce AWS costs for a startup. '
            'Label each with: [IMMEDIATE] if doable today, [MEDIUM] if takes 1-2 weeks, or [LONG] if takes a month+. '
            'Also label each with estimated monthly savings: ($50-200) ($200-500) ($500+). '
            'Each item: one sentence.'
        )
    }]
)
print(response.choices[0].message.content)

Nested Lists

Nested lists add one level of hierarchy — useful for organizing ideas that have natural groupings:

Main categories at level 1
Specific examples or sub-points at level 2

Request: 'Create a two-level outline with 4 main sections and 3 sub-points each.' Be careful — more than 2 levels deep becomes hard to read in most contexts.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=400,
    messages=[{
        'role': 'user',
        'content': (
            'Create a 2-level outline for a "Python for Data Science" beginner course. '
            'Level 1: exactly 4 module titles. '
            'Level 2: exactly 3 lesson titles under each module. '
            'Format as nested markdown bullets. '
            'Lesson titles should be specific — not generic like "Introduction".'
        )
    }]
)
print(response.content[0].text)

Ranked and Ordered Lists

When order carries meaning, specify the ranking criterion explicitly:

'Rank from most impactful to least impactful'
'Order from quickest to implement to most time-intensive'
'List in order of risk — highest risk first'
'Sort alphabetically'

Without explicit ordering, the model may list items in the order they came to mind, which is not necessarily the most useful order for you.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{
        'role': 'user',
        'content': (
            'List 6 database indexing strategies for PostgreSQL. '
            'Order: from most commonly needed to most specialized. '
            'Each item: strategy name in bold, followed by a 10-word description, '
            'then a note of when NOT to use it in parentheses.'
        )
    }]
)
print(response.choices[0].message.content)

Anti-Patterns: Lists That Fail

Common list request mistakes that produce bad output:

No count: 'Give me some bullet points' → variable length, often too short or too long
No item structure: model chooses its own mix of long and short items
Asking for too many items: 'List 50 ideas' → last 30 are padded filler
Nested too deep: 3+ levels → output becomes unreadable

Best practice: 5-15 items with a specified per-item structure is the sweet spot for most use cases.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

# Anti-pattern: no count, no structure
bad_prompt = 'Give me some ideas for blog posts about Python.'

# Good pattern: count + structure + ordering
good_prompt = (
    'Generate 8 Python blog post title ideas. '
    'Target audience: intermediate Python developers (2-3 years experience). '
    'Mix: 4 practical how-to titles, 4 conceptual deep-dive titles. '
    'Label each [HOW-TO] or [DEEP DIVE]. '
    'Each title: max 10 words. No clickbait.'
)

for label, prompt in [('BAD', bad_prompt), ('GOOD', good_prompt)]:
    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=200,
        messages=[{'role': 'user', 'content': prompt}]
    )
    print(f'--- {label} ---')
    print(response.content[0].text.strip())
    print()

List Output in Programmatic Contexts

When using AI to generate lists that will be processed by code, request output in a machine-parseable format:

JSON array: 'Output as a JSON array of strings'
One item per line: 'Output exactly one item per line, no bullets, no numbers'
CSV: 'Output as a single comma-separated line'

This avoids the need to parse markdown bullets from the response string.

import openai
import json

client = openai.OpenAI(api_key='sk-your-key-here')

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{
        'role': 'user',
        'content': (
            'List 8 Python standard library modules that every developer should know. '
            'Output as a valid JSON array of strings only. '
            'No explanation, no formatting, no markdown — just the raw JSON array.'
        )
    }]
)

raw = response.choices[0].message.content.strip()
try:
    modules = json.loads(raw)
    print(f'Parsed successfully: {len(modules)} modules')
    for m in modules:
        print(f'  - {m}')
except json.JSONDecodeError as e:
    print(f'Parse error: {e}')
    print('Raw output:', raw)

Knowledge Check

A team lead wants to generate an action item list from an AI assistant. They send: 'Give me some action items.' The result is 4 vague bullet points. Which rewrite produces the most useful output?

Requesting Lists — Recap

Lists are one of the clearest output formats to request. Mastering list requests means specifying:

Exact count: always provide a number, not 'some' or 'a few'
Format: bullets, numbers, checklist, nested
Per-item structure: one sentence / two sentences / title + description
Labels: difficulty, time, team, category
Ordering: most important first, ranked by X, alphabetical
Machine format: JSON array or one-per-line for programmatic use

Frequently asked questions

Is the “Requesting Lists and Bullet Points” lesson free?

Yes — the full text of “Requesting Lists and Bullet Points” is free to read here on the web, and the AI Prompt Engineering course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the AI Prompt Engineering course, upgrade to CoddyKit PRO.

What will I learn in “Requesting Lists and Bullet Points”?

Ask AI for numbered or bulleted lists with specific item counts. You practise AI Prompt Engineering with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start AI Prompt Engineering?

No prior experience is required. AI Prompt Engineering on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Requesting Lists and Bullet Points” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this AI Prompt Engineering lesson?

Yes. Every AI Prompt Engineering lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to AI Prompt Engineering