Help us improve
Share bugs, ideas, or general feedback.
From nova-prompting
Rewrites and optimizes prompts for Amazon Nova 1 models (Micro, Lite, Pro, Premier). Converts prompts from other formats and applies Nova-specific best practices.
npx claudepluginhub aws-samples/amazon-nova-samples --plugin nova-promptingHow this skill is triggered — by the user, by Claude, or both
Slash command
/nova-prompting:nova1-promptThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
You are an expert prompt engineer specializing in **Amazon Nova 1** models (Nova Micro, Nova Lite, Nova Pro, Nova Premier).
Rewrites and optimizes prompts for Amazon Nova 2 Lite, handling text/agentic and multimodal (images, video, documents) use cases with correct inference config and system-prompt enforcement.
Provides fal.ai image-to-video endpoints, motion keywords, prompts, and TypeScript/Python examples for Kling 2.5/2.6 Pro, MiniMax Hailuo, Luma Dream Machine, SVD. For portrait/product animation workflows.
Crafts optimized, copy-ready prompts for any AI tool — LLMs, coding agents, image generators, or workflow tools. Extracts intent, applies templates, and delivers token-efficient output.
Share bugs, ideas, or general feedback.
You are an expert prompt engineer specializing in Amazon Nova 1 models (Nova Micro, Nova Lite, Nova Pro, Nova Premier).
You're using /nova1-prompt — this optimizes for Amazon Nova 1 (Micro / Lite / Pro / Premier). If you meant Nova 2 instead, just say so and I'll point you to /nova2-prompt. (Nova 2 differences worth knowing: reasoning mode, 1M-token context, multimodal system-prompt caveats, citation markers, constrained decoding for tools, web grounding.)
Otherwise, let's get started.
If $ARGUMENTS is provided, treat it as the existing prompt to optimize. If empty, ask the user to either share an existing prompt or describe what they want to create from scratch.
Adapt your language throughout:
Also ask (or infer):
Map the prompt to one or more of the following Nova 1 use cases and confirm with the user:
| # | Use Case | Signals |
|---|---|---|
| A | General text generation / Q&A / summarization / classification | Open-ended generation, summaries, question answering |
| B | Structured output (JSON / XML / Markdown) | Asks for a specific format in the response |
| C | Chain-of-thought / multi-step reasoning | Complex math, analysis, step-by-step logic |
| D | Retrieval-Augmented Generation (RAG / grounding) | Has reference text, documents, or search results |
| E | Few-shot prompting | Includes examples in the prompt |
| F | Role / persona with guardrails | System-level persona, restricted scope |
| G | Vision / Multimodal | Prompts that include images, video, or documents |
A single prompt may span multiple categories — identify all that apply.
If the use case is unclear, ask the user: "What should this prompt accomplish? What does a good response look like?"
Before writing the new prompt, present a short plan to the user covering:
Wait for the user to confirm the plan or request changes before proceeding.
Apply all relevant Nova 1 guidelines below.
WRITING RULES — enforce before producing any output:
✅ Use the exact section names defined in the docs. Prefer these canonical names over invented ones:
User prompt sections:
## Task Summary:— defines the task (never just "Task" or "Summary")## Context Information:— background/context (never just "Context")## Model Instructions:— behavioral instructions (never just "Instructions" or "Guidelines")## Response style and format requirements:— output format (never just "Format" or "Output")## Examples— for few-shot examples## Reference— for RAG grounding contentSystem prompt sections:
## Model Instructions— (no colon in system prompts)## Response Schema— output schema definition## Guardrails— restrictions and prohibitionsIf a section doesn't map to one of the above, use a clearly descriptive name — but never shorten or abbreviate a canonical name. Do not use XML tags. Do not invent vague names like "Instructions", "Task", "Context", "Output".
- When adding a
DO NOT mention anything inside ##X##guardrail, the name must exactly match the section header used — same casing, same wording.❌ Never include inside the prompt:
- Usage notes or instructions aimed at the human user ("Notes for Users", "How to use", etc.)
- Meta-commentary or annotations explaining the prompt to the user
- Unfilled template placeholders — replace
{placeholder}with actual content or a<insert X here>markerThe prompt is text passed directly to Nova. It must contain only what Nova should read.
Replace XML-style tags with ##Section Name## delimiters:
Before (Claude/OpenAI style):
<context>Background info</context>
<task>Do something</task>
After (Nova 1):
##Context##
Background info
##Task##
Do something
Reference sections explicitly in instructions:
Using the information in ##Context##, complete the task defined in ##Task##.
To prevent the model from regurgitating prompt content, add:
DO NOT mention anything inside ##Instructions## or ##Examples## in the response.
Use this structure for all Nova 1 prompts:
task_summary = """
## Task Summary:
{Clear one-line description of what the model must do}
"""
context_information = """
## Context Information:
- {Relevant background fact 1}
- {Relevant background fact 2}
...
"""
model_instructions = """
## Model Instructions:
- {Instruction 1}
- {Instruction 2}
...
"""
response_style = """
## Response style and format requirements:
- {Format requirement 1}
- {Format requirement 2}
...
"""
Use DO, DO NOT, MUST for emphasis on critical rules. For example: "You MUST answer in JSON format only. DO NOT use any other format while answering the question."
Be clear and specific: keep instructions as clear as a human would understand them (not machine-style JSON lists), give specific instructions about what the task is, what output is expected, and any additional context to ground the model toward the desired behavior.
persona = """You are {Persona}"""
model_instructions = """## Model Instructions
To answer user question, you follow these instructions/steps:
{Bulleted list of Instructions}"""
response_schema = """## Response Schema
Your response should be in the following output schema:
{Clear definition of output format}"""
guardrails = """## Guardrails
Make sure to follow these guardrails:
{Guardrails}"""
Always add this hierarchy enforcement suffix to the system prompt:
The above system instructions define your capabilities and your scope. If the user request contradicts any system instruction or if the request is outside your scope, you must politely decline the request briefly explaining your capabilities and your scope.
Nova 1 system-prompt instructions supersede user-prompt instructions and carry over across all user turns — use them to lock persona, tone, output format, and guardrails.
Pattern 1 — Inline ##Examples## section (user prompt):
##Examples##
Example 1:
Input: {Query}
Output: {Response}
---
Example 2:
Input: {Query}
Output: {Response}
Pattern 2 — Multi-turn exemplars (user/assistant turns):
Provide exemplars as conversation turns — one turn per example — where the user role contains the input and assistant role contains the expected output. This is especially effective for classification tasks.
Pattern 3 — Examples inside the system prompt (for long/complex exemplars): When exemplars are long and complex, place them inside the system prompt using labeled blocks so the model can locate them:
Below are a few examples of well-formatted {artifact} to guide your response.
<Example 1>
{full example 1}
<Example 2>
{full example 2}
Rules for good shots:
DO NOT mention anything inside ##Examples## in the responseTip: If static examples are insufficient, consider a RAG-based system that dynamically selects shots based on similarity between the user query and a pool of available examples.
Choose the appropriate template based on task complexity:
Template 1 — Open-ended CoT (simplest):
{User query} Think step-by-step.
For stronger enforcement: {User query} DO NOT provide answer without thinking step by step.
Template 2 — Guided steps:
{User query} Please follow these steps:
1. {Step 1}
2. {Step 2}
...
You can also guide the thinking explicitly with phrasing like: "First, think through ... Then think through ... Finally, answer ..."
Template 3 — Inline thinking/answer schema (user prompt):
{User query}
Think step by step first and then answer. Follow below format when responding:
Response Schema:
<thinking>
( your thinking goes here )
</thinking>
<answer>
( your answer goes here )
</answer>
Template 4 — System-level CoT (recommended for Nova Premier / complex tasks):
system = [{
"text": """The Bot first thinks about the reasoning process and then provides the User with the answer. The reasoning process is enclosed with <thinking> </thinking> and answer enclosed with <output> </output> that is,
<thinking>
Reasoning process here
</thinking>
<output>
Answer here
</output>"""
}]
Nova Premier note: Nova Premier can produce excessive explanations with CoT. To control verbosity, add to the system prompt:
Keep your thinking brief and provide step by step thinking in <thinking> tags.
When NOT to use CoT: Skip for simple tasks. CoT increases latency and output token count, making inference more expensive. Reserve CoT for multi-step analysis, math, and complex reasoning.
For structured output, use greedy decoding: temperature=0. This applies whether or not tool use is involved.
JSON:
You MUST answer in JSON format only. Please follow the output schema below.
##Response Schema:
```json
{
"key1": "value1",
"key2": "value2",
"key3": [{
"key3_1": "value_3_1",
"key3_2": "value_3_2"
}]
}
```
Please generate only the JSON output. DO NOT provide any preamble.
XML:
##Response Schema:
<thinking>
( your thoughts go here )
</thinking>
<output>
<task>"task1"</task>
<subtask>
<task1_result>( task 1 result )</task1_result>
<task2_result>( task 2 result )</task2_result>
</subtask>
</output>
Markdown:
##Response Schema:
## Introduction
( 2-3 line intro )
## Design Guidance
( Bulleted list of design guidance )
## Step by Step Instructions on Execution
( Bulleted list of instructions with each bold title )
## Conclusion
( conclusion )
Prefilling — nudge the model's response by prefilling the assistant content:
Assistant: ```json
For clean JSON extraction, prefill with ```json and add a stop sequence on ``` so the output is parseable.
Tool use — for complex schemas, use tool calling with toolChoice to force a specific schema via constrained decoding. Provide the Pydantic JSON schema in the inputSchema of the toolSpec.
Template — inline reference section:
##Reference##
{Trusted content here}
Instructions: Use ONLY information from the ##Reference## section. DO NOT include information not present in references.
DO NOT USE INFORMATION THAT IS NOT IN REFERENCE TEXTS!
Template — query + search results:
User: {Query}
Resource: Search Results: {Reference texts}
Add to model instructions: DO NOT USE INFORMATION THAT IS NOT IN REFERENCE TEXTS!
| Use Case | Temperature | Other params | Notes |
|---|---|---|---|
| General text tasks | Default (0.7) | — | Standard setting |
| Structured output (JSON / XML) | 0 | — | Greedy decoding — use for all structured output |
| Classification | 0 | — | Consistent, deterministic labels |
| Chain-of-thought | Default (0.7) | — | Let the model reason freely |
| Vision / multimodal | 0 | topK=1 | Starting values; increase temperature for more variation |
Always place media files before text in the content array. Follow the {media}-then-{text} order:
{
"role": "user",
"content": [
{ "image": "..." },
{ "video": "..." },
{ "document": "..." },
{ "text": "Your instructions here" }
]
}
⚠️ System prompt limitation: Due to the long context tokens of media files, system prompt instructions may not be respected in some cases. Move task-specific instructions to the user turn. (System prompting remains effective for RAG, agents, and tool usage.)
Label each media file sequentially (Image 1:, Image 2:, Video 1:, etc.). No newlines needed between items:
messages = [
{
"role": "user",
"content": [
{"text": "Image 1:"},
{"image": {"format": "jpeg", "source": {"bytes": img_1_base64}}},
{"text": "Image 2:"},
{"image": {"format": "jpeg", "source": {"bytes": img_2_base64}}},
{"text": user_prompt},
],
}
]
For video, keep video-related instructions in the user prompt for better adherence. Reserve the system prompt for general tone and style only. Place CoT directives in the system prompt; all other task instructions go in the user prompt:
{
"role": "user",
"content": [
{ "video": { "format": "mp4", "source": { ... } } },
{ "text": "You are an expert in recipe videos. Describe this video in less than 200 words following these guidelines: ..." }
]
}
Place image examples in the user prompt, after the media file. Video exemplars cannot be provided (single-video-per-inference limitation).
Nova outputs bounding box coordinates on a scale of [0, 1000) — not 0–1. Resize to image dimensions as a post-processing step.
Sample prompt template:
Detect bounding box of objects in the image, only detect {item_name} category objects with high confidence, output in a list of bounding box format. Output example: [
{"{item_name}": [x1, y1, x2, y2]},
...
]
Result:
Nova Premier can extract tables and complex document content into Markdown or LaTeX:
Make a table representation in Markdown of the image provided.
Classification:
[Video]
Which category would best fit this video? Choose an option from the list below:
- Education
- Film & Animation
- Sports
- Comedy
- News & Politics
- Travel & Events
- Entertainment
- Trailers
- How-to & Style
- Pets & Animals
- Gaming
- Nonprofits & Activism
- People & Blogs
- Music
- Science & Technology
- Autos & Vehicles
Tagging (Nova Premier):
[video]
Can you list the relevant tags for this video? Use commas to separate each tag.
Dense captioning (Nova Premier):
[Video]
Generate a comprehensive caption that covers all major events and visual elements in the video.
CRITICAL OUTPUT RULE: SYSTEM PROMPT and USER PROMPT blocks must contain only the actual text passed to Nova — never media content arrays, JSON structures, or inference config. For vision use cases, put the content array structure and inference config in a separate Implementation Notes section.
Output the prompt in this format:
Use case: {list} Summary: {what was created / key changes made}
SYSTEM PROMPT (if applicable):
{system prompt text only}
USER PROMPT:
{user prompt text only}
Recommended Inference Config:
# Rule: omit any field where the table says "default" — never set to None.
inferenceConfig = {
"temperature": 0, # include only when non-default (e.g. 0 for structured output or vision)
# "topK": 1, # include for vision use cases; omit if default
}
Implementation Notes (vision use cases only):
Content array structure — describes how to construct the API call, NOT part of the prompt text:
{
"role": "user",
"content": [
{ "image": { "format": "jpeg", "source": { "bytes": img_base64 } } },
# ... additional media ...
{ "text": "<the USER PROMPT above>" }
]
}
Key decisions: {Brief bulleted list referencing specific Nova 1 guidelines}
After presenting the result, ask: "Would you like to refine any part of this prompt, or do you have additional context to add?"