Prompt & Skills Library

Act as a senior SEO content editor with 10 years of experience.
Write an article on the topic: [the topic].
Target audience: [who the readers are].
Primary keyword: [keyword]. Secondary keywords: [2-3 words].

Requirements:
- An H1 title that contains the keyword and drives clicks (up to 60 characters)
- A 2-3 sentence intro that states the problem and what readers will learn
- 4-6 subheadings (H2) with practical content under each
- Short paragraphs, clear language, no filler
- A conclusion with a call to action
- A meta description up to 155 characters

Keep it accurate. Do not invent facts or figures.

Write a LinkedIn post on the topic: [the topic / insight].
Personal angle: [a story / experience / opinion of mine].
Audience: [managers / developers / business owners].

Structure:
1. An opening line that stops the scroll (a hook) — one sharp sentence
2. 3-5 short lines with the core insight, line by line
3. A short list or 3 practical takeaways
4. An open question at the end that invites comments

Tone: human, confident, no buzzwords and no excessive emojis.
Length: up to 150 words. Use no more than 3 hashtags.

Act as an experienced, direct content editor. Here is a text I wrote:
"""
[paste your text here]
"""

Give me:
1. Three key weaknesses in the text (structure, clarity, tone)
2. An improved, tightened version — at least 20% shorter
3. Three alternative titles
4. One note on the most important thing to fix next time

Be honest and direct, don't flatter for the sake of it. Keep my original voice.

I want to build a newsletter series on the topic: [the topic].
Audience: [description]. Goal: [educate / sell / build authority].

Propose:
- A name for the series + a one-sentence value promise
- 5 emails: for each, a subject line, an opening sentence, the core content point, and one clear CTA
- An idea for a lead magnet that fits the series

Present it as a table. Keep to one email = one idea. No clickbait.

Act as a process automation consultant. I want to turn a manual process into an automated one.
The process: [briefly describe what happens today, step by step].
Tools I have: [e.g. Gmail, Google Sheets, WhatsApp, CRM].

Give me:
1. A breakdown of the process into a trigger, steps, and conditions
2. Which steps can be automated and which need a human (human-in-the-loop)
3. A proposed architecture with n8n or Make (the main nodes)
4. Possible failure points and how to handle them (error handling)
5. An estimate of the time saved per month

Present it in a structured way with headings. Don't assume tools I didn't mention.

I'm considering building an AI Agent for the task: [describe the task].
Volume: [how many times a month]. Current manual cost: [time/money].

Help me decide objectively:
1. Is this a problem that really needs an agent, or would a simple workflow / script do?
2. Three real risks (accuracy, cost, maintenance) for my scenario
3. Conditions under which it pays off — and conditions under which it's better not to
4. The smallest MVP I can test with before a big investment

Be honest. If the answer is "not worth it" — say so explicitly and why.

Turn the following description into a clear standard operating procedure (SOP) for the team:
"""
[describe the process in your own words, even if it's not organized]
"""

Output format:
- Purpose of the procedure (one sentence)
- When it's triggered (trigger)
- Numbered steps, each step in a single action sentence
- Responsibility: who does each step
- Quality control: how you know it succeeded
- Edge cases and what to do about them

Write it so a new employee can carry it out with no questions. Simple language.

Do a code review of the following code. Language: [language]. Context: [what the code is supposed to do].
"""
[paste the code]
"""

Review by priority and present as a list:
1. Bugs and correctness issues (with the scenario that breaks them)
2. Security issues (unsanitized input, secrets, injection)
3. Performance (complexity, redundant calls, N+1)
4. Readability and maintainability

For each finding, note the line, why it's a problem, and a concrete fix.
Don't rewrite the whole thing — only what's needed. If something is fine, don't invent a problem.

I'm hitting a bug and can't solve it. Help me systematically, not by guessing.

What happens: [the actual behavior]
What I expected: [the desired behavior]
Error message: [if any]
Relevant code:
"""
[paste]
"""

Work like this:
1. Formulate 3-4 hypotheses for the cause, most likely to least
2. For each hypothesis: how to verify it quickly (a check / log / breakpoint)
3. Wait for my results before you suggest a fix
4. Only after we've confirmed the cause — propose the minimal fix

Don't jump straight to a solution.

Write tests for the following function. Language: [language]. framework: [pytest / jest / ...].
"""
[paste the function]
"""

Cover:
- The happy path
- Edge cases (empty, zero, large values, unexpected input)
- Failure cases and error handling
- Boundary values

Give each test a clear name describing what it checks. Add a short comment for non-obvious cases. Don't test the language itself — only my logic.

Build me a 30-day content plan.
Business: [description]. Platform: [LinkedIn / Instagram / blog].
Audience: [who]. Goal: [awareness / leads / sales].

Give:
- 3 content pillars that fit the audience
- A 30-day calendar: for each day a topic + format + hook + CTA
- 5 content ideas that can be repurposed into several formats

Present it as a weekly table. Keep an 80% value / 20% sales ratio. No overblown promises.

Write 3 versions of a cold sales email.
I'm selling: [product/service]. To an audience of: [who]. The problem I solve: [the problem].

For each version:
- A short subject line (up to 6 words) that doesn't sound like spam
- A personalized opener that shows I did my homework
- One clear value sentence — what the customer gets
- One soft CTA (a question, not "let's schedule a meeting")

Length: up to 90 words. No superlatives, no "revolutionary". A human tone, not a sales robot.

I want to analyze a competitor. Name/site: [the competitor]. My field: [field].
(If you have web access — check up-to-date sources and cite them.)

Give me an analysis:
- Their core value proposition and target audience
- 3 strengths and 3 weaknesses I can exploit
- How they price / position themselves
- A gap in the market I could capture
- 3 practical moves I could make this month

Separate facts you found from estimates. Don't invent figures.

Here is some data (attached file / table). The goal of the analysis: [what I want to understand].

Do:
1. A short description of the data — columns, ranges, missing values
2. 5 key insights, each with the number that supports it
3. Outliers or things that need checking
4. 3 action recommendations derived from the data
5. The one chart most worth showing (and describe it)

Don't infer beyond what the data shows. If information is missing for an answer — say so.

Here is a meeting transcript / summary:
"""
[paste the transcript]
"""

Produce:
- A 3-point summary of what was decided
- A task table: task | owner | due date (if stated)
- Open decisions that need follow-up
- One question worth making sure wasn't forgotten

Don't invent owners or dates that didn't appear. Mark "not specified" where something is missing.

I need to choose between options. The decision: [what's being decided].
Options: [A], [B], [C].
What matters to me (criteria): [cost, time, risk, ...].

Help me:
1. Build a comparison table: option vs. criterion (score 1-5)
2. Note assumptions I'm making that might not be true
3. What's your recommendation and why — including one caveat
4. What missing information would change the decision

Ask me one question if you're missing critical context before you conclude.

---
name: n8n-workflow-builder
description: Builds a valid n8n workflow from a natural-language description, including nodes, connections and error handling.
---

# When to use
When the user describes an automation they want to build in n8n.

# Steps
1. Identify the trigger (Webhook / Schedule / an app event).
2. Break the flow into nodes in order, and specify the node type for each step.
3. Define the connections between nodes, including branches (IF/Switch).
4. Add a node for error handling (Error Trigger) and retry logic.
5. Return valid JSON that can be imported into n8n (Import from File).

# Rules
- Don't invent credentials. Mark a clear placeholder.
- Make sure every reference to a prior node exists.
- Prefer a simple solution over a complex one.

---
name: rag-answerer
description: Answers questions only from the documents provided, with source citations, and admits when there is no answer.
---

# When to use
When you need to answer questions from a corpus of documents (support, organizational knowledge).

# Steps
1. Retrieve the most relevant passages for the question (top-k).
2. Answer strictly based on the retrieved passages.
3. Cite the source for every claim (file name / passage ID).
4. If the answer isn't in the sources — say "No answer found in the sources" and do not fill in from general knowledge.

# Rules
- Zero hallucinations: prefer "I don't know" over a guess.
- Keep the language of the question (Hebrew/English).
- If the question is ambiguous — ask one clarifying question before answering.

---
name: security-reviewer
description: Reviews code to find common security vulnerabilities per OWASP, with severity and a fix recommendation.
---

# When to use
Before merging code that handles user input, authentication, or data access.

# Steps
1. Go through the code and look for: injection, broken authentication/authorization, exposed secrets, unsanitized input, unsafe deserialization.
2. For each finding note: file+line, vulnerability type, severity (high/medium/low), the exploitation scenario.
3. Propose a concrete, minimal fix for each finding.
4. Mark a certain finding vs. one that needs manual review.

# Rules
- Don't report a "problem" that has no real exploitation scenario.
- Rank by real risk, not by quantity.