# AI prompt analyzer

> How a free AI prompt analyzer scores a prompt 0–100 on six criteria, with real before → after examples (20 → 64, 19 → 84) and the fixes that made the difference.

Source: Promptea — https://www.promptea.me/en/landing/prompt-analyzer · Language: English · Last updated: 2026-11-14

A prompt analyzer checks a prompt before you send it to ChatGPT, Claude, Gemini or any other AI. Promptea reviews yours against criteria that matter for the task you pick — coding, data, marketing, study, image, translation, or summary.

You get a score, the missing pieces, what to fix first, and an optimized version ready to copy.

How it works: paste the prompt, choose its purpose and the AI you will use, and the analyzer applies fixed rules — the same prompt always gets the same score. It lists the findings in order of impact, writes an optimized version and scores that version again, so you see a before → after score. Promptea optimizes prompts; it does not run them on a model.

- Score breakdown by clarity, context, constraints, output, and verifiability.
- Targeted follow-up questions when the prompt is too ambiguous.
- Optimized output as a human-readable checklist or strict JSON.

## Before → after examples

### Marketing copy: from a one-liner to a brief

Before (score 20/100):

```text
Write a product description for our app.
```

After (score 64/100):

```text
Write a product description for Tasklight, our to-do app for freelancers.
Audience: freelance designers who juggle 5+ clients.
Goal: get them to start the free trial.
Include: the two features that matter most to them (client folders, invoice reminders) and one concrete benefit.
Constraints: 80–100 words, plain language, no superlatives or made-up stats.
Call to action: end with "Start your free 14-day trial".
Output format: a headline (max 8 words), then one paragraph.
Success check: a freelancer can tell in one read what Tasklight does and what to click.
```

The analyzer flagged a missing audience, context, output format and call to action. The rewrite states all four, plus a length limit and a way to check the result.

### Debugging: from "fix it" to a reproducible bug report

Before (score 19/100):

```text
my code doesn't work, fix it
```

After (score 84/100):

```text
My Python function returns None instead of the total.
Expected: sum_prices([{"price": 2}, {"price": 3}]) returns 5.
Actual: it returns None. No error is raised.
Code:
def sum_prices(items):
    total = 0
    for item in items:
        total += item["price"]
Constraints: keep the signature; Python 3.11; no new dependencies.
Steps to reproduce: call sum_prices([{"price": 2}, {"price": 3}]) in a Python 3.11 shell.
Output format: 1) the cause in one sentence, 2) the fixed function in a code block, 3) one pytest test that would have caught it.
```

A debugging prompt needs what you expected, what happened, the code and how to reproduce it. With those four the model can find the bug instead of guessing it (here, the missing return).

### JSON extraction: a decent score that still misses the schema

Before (score 63/100):

```text
Extract the important info from these emails as JSON.
```

After (score 78/100):

```text
Context: these are emails from our sales inbox; the result fills our team calendar.
Extract every meeting request from the emails below.
Return only JSON: an array of objects with the fields "sender" (string), "date" (YYYY-MM-DD or null), "time" (HH:MM, 24h, or null) and "topic" (max 10 words).
If an email has no meeting request, skip it. If a field is missing, use null; do not guess.
Example: [{"sender": "Ana Ruiz", "date": "2026-11-20", "time": "15:00", "topic": "Q4 budget review"}]
Emails:
"""
[paste the emails here]
"""
```

Asking for JSON already earns points for output format, but without fields, types or the input the model invents its own schema every run. Naming the fields, the null rule and one example makes the output parseable.

## Frequently asked questions

### What is a prompt analyzer?

A tool that reads a prompt before you send it to an AI and tells you what is missing: the goal, the context, the constraints, the output format or a way to check the answer. Promptea also scores the prompt from 0 to 100 and writes an improved version.

### How is the score calculated?

Six criteria — clarity, context, constraints, output, verifiability and safety — each scored by fixed rules and weighted by the task you pick. Verifiability counts more for debugging than for a casual text request. The same prompt always gets the same score.

### Is the prompt analyzer free?

Yes. It is free and needs no account or sign-up: paste a prompt and analyze it.

### Does it run my prompt on ChatGPT or Claude?

No. Promptea analyzes and rewrites the prompt; you copy the result into the AI you use. The score comes from rules, not from asking another model to grade it.

### Which AI models does it optimize for?

GPT, Claude, Gemini, Grok, Kimi, DeepSeek, Perplexity, Qwen, GLM, MiniMax, Doubao. Each one gets the structure its provider documents (for example, long context before the question for Gemini, or explicit acceptance criteria for DeepSeek).

### Is my prompt stored?

Promptea collects usage metadata, not the text of your prompts. Saving a prompt to your library keeps it in your own browser.

- [How prompt scoring works](https://www.promptea.me/en/guides/prompt-quality-scoring)
- [Debug a prompt that fails](https://www.promptea.me/en/guides/prompt-debugging)
- [Prompt packs](https://www.promptea.me/en/prompts)
- [Guides](https://www.promptea.me/en/guides)
- [Prompts by model](https://www.promptea.me/en/models)
