Writing better prompts helps you get the most out of Polymet. While we provide system-level assistance, prompts written by you with real context consistently lead to better results. Here are our best practices for crafting powerful prompts:

​
Use your product context

Don’t just say, “Generate a table.” Instead, explain where the table will be used, who the user is, and what problem it solves.
Example: “Create a pricing table for a SaaS product targeting early stage AI-agent startups. It should compare three plans(basic, starter and pro) and highlight features like figma integrations, maximum user limits, and priority support. Use FF6600 as a primary color.”

​
Focus on your product, not technical details

Technical stacks don’t help. Polymet works best when you describe how your product works, who it’s for, and what kind of experience you want to create.
Include details like:
  • What the user sees and does
  • The problem your product solves
  • Existing UI/UX flows
  • Preferred design styles or themes

​
Build step by step

Trying to generate an entire product in one go often fails. Work iteratively:
  1. Start with one page (e.g., the dashboard home).
  2. Add more pages (e.g., analytics, settings).
  3. Add interactions and flows later.
    This leads to better structure, clarity, and consistency.

​
Include context in your prompts

Each prompt should be self-contained. Provide enough information, like:\
  • “I’m building an onboarding page for a fintech app. The goal is to guide new users through account setup.”\
  • “We’re designing a user settings page for managing notifications and privacy.”
    Even brief context improves results.

​
Be specific and set clear limits

Narrowing the scope helps. The more specific your instructions, the more creative Polymet can be within those boundaries.
Example:
“Create a hero section with a product image on the right and a CTA on the left. No navbar yet. Targeting designers.”

​
Keep prompts focused

As your project grows, avoid prompts that cover multiple components or pages at once. Break down complex tasks:
  • First, create the first page by using context of the page and style information.
  • _Then, refine the style and set your preferences. _
  • Then, build your other pages, and stick to one goal per prompt for better results.

​
Define your style early

Set design tokens and visual language upfront—spacing, fonts, colors, radii—so new pages align automatically. As changing full projects styles later is harder.

​
Create flows with prompts

Once your designs are ready, define flows by prompting actions for specific elements.
Example:
“When users click this button, open a modal with...”

​
Using image prompts

When you upload an image, Polymet tries to replicate its style and layout. For more control, combine images with descriptive text prompts.

​
Import your Figma files starting point

If you already have a Figma design, use “Polymet x Figma plugin” and import your design frames into Polymet and build on top of it.

​
Create a mini design system prompt

If you’ve already have a design system documentation and wanted to use those information in your generations, prepare a guideline for your first prompt by using LLMs, or manually - which includes:
  • Brand foundations (voice & tone, design principles, )
  • Color system (palette swatches) & color usage rules
  • Typoghraphy (token, size, weight, letter-space, usage)
  • Spacing, layout & grid (breakpoints, max-widths, border radius)
  • Iconography (icon library, stroke) - we’re using lucide-react
  • Motion (animation information)
  • Components (components, core actions, irreversible actions, states)
  • UX patterns (general ux overview of the product)
  • Accessibility checklist (ARIA roles, text scaling, color rules)
Make sure that the generated mini design system prompt is not bigger than 6K character limitations.

​
Write naturally

Use full sentences and clear, specific language. Polymet is an AI product designer, but it learns best from natural, human-like instructions.

​
Multiple prototypes

You can create multiple prototypes in the same project. They can reuse components and pages but follow different user flows. Main use-case: users can create different prototypes to see different variations of the same problem.

​
Make it conversational

Even for small features, keep it conversational. Polymet remembers your project context, so adjust prompts as needed for better results.

​
Control the scope

Polymet rewrites or modifies files based on your prompt. Be explicit about what to change and what to leave untouched.
Example:
“Update core functionality and implement edits, but leave other features and flows as is.”

​
Lock files (conceptually)

While you can’t lock files, you can signal areas not to change by including phrases like:
“This update is delicate. Review dependencies carefully, avoid disruptions, and ensure files x, y, and z remain unchanged.”

​
Optimize for mobile

Polymet generates responsive designs, but you can still prompt mobile-first improvements:
“Optimize for mobile while maintaining the current design and functionality. Test across devices to ensure proper layout and responsiveness.”

​
Ask for reasoning

Polymet starts with a plan before building, but you can ask for explicit reasoning:
Example:
“Before editing, create a phased plan for adding responsiveness. Prioritize layout components, then refine smaller elements. Share the plan for review.”

​
Refactoring

For performance improvements, prompt Polymet to refactor code:
“Refactor this file without changing its UI or functionality. Document existing behavior, improve maintainability, and proceed cautiously to prevent issues.”

​
Review refactoring

After refactoring, review to confirm nothing broke:
“Conduct a post-refactor review. Ensure the UI and functionality are unchanged. Compare the app’s behavior with pre-refactor specs and flag discrepancies.”

​
Debugging prompts

Tackle issues one at a time. Try the “Fix errors” option up to three times before exploring other solutions.
You can use any LLM that can good at coding when debugging outputs, it’d be better if you give:
  • Context about the error you encountered
  • Console logs
  • Screenshots, if needed
Ask for specific solutions, not high-level explanations. For example:
“Don’t give me general advice—show me the code or provide a concrete fix. Be concise, precise, and proactive.”

​
Handling unexpected outputs

If the generated code is good to go but your app behaves unexpectedly:
  1. Retrace your prompts.
  2. Break down the problem.
  3. Use rollbacks and rephrase your prompt.
By following these principles, you’ll help Polymet generate higher-quality results, reduce rework, and move faster across every stage of your design process. If you’d like to suggest new methods that you’ve tried before, please share with us at support@polymet.ai