Your first no-code AI automation: trigger, AI step, draft for approval

I'll describe my recurring work, and you pick the first scenario
worth automating.

What I do repeatedly:
[list 8-12 activities; for each: how often, how many minutes it
takes, where the data comes from, and where you store it]

Tools I use: [list them]

Give me:
1. Those activities ranked by time saved / build effort
2. For the three best, sketch out the scenario: what triggers it,
   which steps follow, where AI fits in, and where the result goes
3. For each of the three, say whether a scheduled routine in an AI
   assistant with connectors is enough, or whether an automation
   platform is needed — and why
4. Which of those activities NOT to automate, and why (too
   infrequent, too many exceptions, too high a cost of error)

Be strict on point 4 — I don't want to automate things I do twice
a month.

I want to build an automation scenario and need a plan before I
start clicking.

What the scenario does: [one-sentence description]
Trigger: [new form entry / webhook from CRM / new file…]
Applications in the chain: [list them in order]
What the result should be: [spreadsheet row, email draft, task…]

Give me:
1. A list of the scenario's steps in order; for each: what it
   receives as input, what it does, what it passes on
2. Exactly where the filter belongs so the scenario doesn't run
   unnecessarily
3. Field mapping: which field from the trigger goes into which
   field in the target application — as a table
4. Which steps can fail and what the scenario should do in each
   of those cases
5. Whether the number of steps can be reduced — and how

Don't write instructions for a specific platform — I want the
scenario's logic.

You are a data extractor for inquiries. You'll receive the raw text
of an inquiry from a web form.

INQUIRY TEXT:
[input from the form]

Return only JSON with these keys, no commentary and no lead-in text:
jmeno, firma, email, telefon, typ_zakazky, rozpocet, termin,
strucne_zadani (max 200 characters), chybi (an array of key names
that were not present in the text)

Rules:
- If a piece of information isn't in the text, write the value
  neuvedeno into that key and add the key's name to the chybi array.
- Do NOT infer anything. Don't estimate the budget from the project
  type, don't derive a deadline from a phrase like "as soon as
  possible" — that's neuvedeno.
- Pick typ_zakazky from: [web, e-shop, grafika, konzultace, jiné].
  If it can't be classified, write jiné.
- Don't correct or restyle the text — you're extracting facts.

You'll receive structured data about an inquiry and information
about my business. Your job is to evaluate the inquiry, not sell it.

INQUIRY:
[JSON from the previous step]

MY FOCUS:
I do [field], a typical project is [description], I don't do
[what I decline]. Smallest project that makes sense for me:
[threshold]. Ideal client: [description].

Return JSON with the keys: znamka, zduvodneni, rizika, prvni_otazky.
- znamka: A (fits my focus and is realistic), B (fits, but
  something is missing or unclear), C (outside my field,
  unrealistic deadline, or clearly out of scope)
- zduvodneni: two sentences, specific, no stock phrases
- rizika: an array of 1-3 sentences — what could be a problem
  (unclear brief, unrealistic deadline, client wants something
  I don't do)
- prvni_otazky: 3 questions I need to ask before I quote a price

When the data is incomplete, evaluate based on what's there —
don't guess at what the project probably looks like.

Write a draft of the first reply to this inquiry. I'm writing as
[name, field], tone: [matter-of-fact and friendly, formal address,
no marketing phrases].

INQUIRY DATA:
[JSON from step A]
EVALUATION:
[JSON from step B]

Rules:
- 150 words maximum, three paragraphs.
- Thank them, summarize in one sentence how I understood the brief,
  and ask the two most important questions from the prvni_otazky
  list.
- Do NOT state a price or a deadline, not even roughly.
- If chybi is non-empty in the data, ask specifically for exactly
  those missing pieces of information, by name.
- If the grade is C, write a polite variant that offers a referral
  elsewhere — but don't reject anyone outright, I'll do that myself.
- Close with the signature [signature].

Return only the email text, no explanation.

You are a triage system for incoming requests. The categories are
fixed — don't invent others.

REQUEST:
Sender: [name and role]
Text: [text from the form]
Attachments: [file names, if any]

Categories: [technical issue, billing, complaint, business inquiry,
HR, other]

Priorities:
- high: something is broken and it's blocking work, or a legal or
  contractual deadline is at risk of being missed
- medium: needs a response within two business days
- low: informational, can wait

Return JSON: kategorie, priorita, shrnuti (max 2 sentences, factual,
not a restatement of the whole text), kdo_by_to_mel_resit (a guess
at the role responsible), chybejici_informace (what needs to be
asked before this can be resolved), citlivost (yes/no — whether the
text contains personal or health information, payroll data, or
anything under confidentiality).

If you're unsure of the category, use other and explain why in
shrnuti. Never assign high priority just because the sender used
all caps or the word urgent.

Compose a team-channel message from the categorized request.

DATA:
[JSON from the previous step]
Link to the original request: [link]

Format:
Line one: priority in caps, category, from whom
Line two: summary, 20 words maximum
Line three: what needs to happen as the first step
Line four: the link

Rules:
- No greetings, no emoji, no lead-in sentences.
- If citlivost is yes in the data, write only "sensitive content —
  open directly in the system" instead of a summary, and don't
  quote any of the text.
- The whole thing has to be readable on a phone without scrolling.

Summarize one article for my newsletter.

I write the newsletter for: [target audience], and they're
interested in [topics]. They're not interested in: [what to skip].

ARTICLE:
Title: [title]
Source and date: [source, date]
Text: [content or lead paragraph]

Return JSON: relevance (0-10), shrnuti (3 sentences: what happened
and why the reader cares), citace (one verbatim sentence from the
article worth quoting — if there isn't one, write an empty string),
pro_koho (which part of my audience this helps most), zdroj_typ
(original report / commentary / reprinted press release / ad).

Rules:
- Rely exclusively on the article text, don't fill in context from
  memory.
- If the article is just a reprinted press release or disguised
  advertising, cap relevance at 3 and note it in zdroj_typ.
- Copy numbers and names exactly, don't round them.

Assemble a newsletter draft from this week's collected items.

ITEMS (sorted by relevance):
[paste the spreadsheet rows: title, summary, link, relevance,
pro_koho]

The newsletter is: [name], published [frequency], written in
[tone: matter-of-fact, slightly personal, no superlatives], length
[about 400 words].

Structure:
1. Opening paragraph (3 sentences) — what the main theme was this
   week across the items. If there's no common theme, say so plainly.
2. Three lead items — for each, a headline, two to three sentences
   in your own words, and a link. Don't copy the summaries verbatim,
   rewrite them in my tone.
3. A short "also worth a look" block — the rest as one-sentence
   bullets.
4. A closing question to the reader, one sentence.

Rules:
- Use only the items I gave you. Don't add anything from memory,
  no "as is well known."
- No claim that isn't in the source material, even if it sounds
  obvious.
- Keep every item's link exactly as it was given to you.
- At the end, attach a CHECK list: numbers and names from the draft
  that I need to verify against the original articles.

I'm attaching the prompt I use in an automated step, along with
twenty real inputs from past months and what the output should
have looked like for each.

PROMPT:
[paste the prompt]

INPUTS AND EXPECTED OUTPUTS:
[paste 20 pairs]

Do three things:
1. Go through the inputs and find the ones where the prompt is
   ambiguous — where the instructions could be read two ways
2. For each ambiguity, propose a specific sentence to add to the
   prompt that removes it
3. List 5 edge cases missing from my set that the prompt is likely
   to fail on (empty input, a foreign language, two inquiries in
   one message, an attachment instead of text, spam)

Don't rewrite the whole prompt — I want targeted fixes with
reasoning.

I'm attaching a description of my automation scenario. I want you
to propose error handling, not praise.

SCENARIO:
[list the steps and applications used]
What happens if the output is wrong: [impact, e.g. a wrong number
gets written into the CRM and nobody notices]

Give me:
1. A table: step | how it can fail | how I'll know | what the
   scenario should do | what I should do
2. Sanity checks I should add between the AI step and the write
   (value ranges, required fields, closed lists)
3. A way to make sure the same input never gets processed twice
4. What the daily summary alert should contain so it can be read
   in ten seconds
5. One test I can run once a month to confirm the scenario is
   actually running

Be specific — generic advice like "monitor it" doesn't help me.