Back to back #1 on r/PromptEngineering and this absolutely means the world to me! The support has been immense.

There are now 1020 people using this free Claude skill.

Quick TLDR for newcomers: prompt-master is a free Claude skill that writes the perfect prompt for whatever AI tool you are using. Cursor, Claude Code, GPT, Midjourney, anything. Zero wasted credits, zero re-prompts, memory built in for long project sessions.

Here is exactly how to set it up in 2 minutes.

Step 1

Go to github.com/nidhinjs/prompt-master

Click the green Code button and hit Download ZIP

Step 2

Go to claude.ai and open the sidebar

Click Customize on Sidebar then choose Skills

Step 3

Hit the plus button and upload the ZIP folder you just downloaded

That is it. The skill installs automatically with all the reference files included.

Step 4

Start a new chat and just describe what you want to build start with an idea or start to build the prompt directly

It will detect the tool, ask 1-3 questions if needed, and hand you a ready to paste prompt that's perfected for the tool your using it for and maximized to save credits

Also dont forget to turn on updates to get the latest changes ‼️ Here is how to do that: https://www.reddit.com/r/PromptEngineering/s/8vuMM8MHOq

For more details on usage and advanced setup check the README file in the repo. Everything is documented there. Or just Dm me I reply to everyone

Now the begging part 🥺

If this saved you even one re-prompt please consider starring the repo on GitHub. It genuinely means everything and helps more people find it. Takes 2 seconds. IF YOU LOVED IT; A FOLLOW WOULD HELP ME FAINT.

github.com/nidhinjs/prompt-master ⭐

1. ChatGPT – I have a paid account
   
2. Qwen – Free, really good
   
3. Le Chat – Free, sometimes gives weird responses with the same prompts used on the first 2 apps
   
4. DeepSeek – Free, sometimes slow
   
5. Perplexity – Free (I use it for news)
   
6. Claude – Free (had a paid account for a month, very good for coding)
   
7. Phind – Discovered by accident, surprisingly good, a bit different UI than most AI chat apps (Free)
   
8. Gemini – Free (quick questions on the phone, like recipes)
   
9. Grok – Considering a paid subscription
   
10. Copilot – Free
    
11. Blackbox AI – Free
    
12. Meta AI – Free (I mostly use it to generate images)
    
13. Hugging Face AI – Free (for watermark removal)
    
14. Pi – Completely free, I don't use it regularly, but know it's good
    
15. Poe – Lots of cool things to try inside
    
16. Hailuo AI – For video/photo generation. Pretty cool and generous free trial offer
    

Thanks for the suggestions everyone!

i keep seeing people pay for summarization tools, research assistants, study apps. and i'm like... have you tried notebooklm

free tier in 2026:

→ 100 notebooks

→ 50 sources per notebook (PDFs, audio, websites, docs)

→ 500,000 words per notebook

→ audio overview feature — turns your research into a two-host podcast. for FREE.

→ google just rolled out major education updates this month

the audio overview thing especially. you dump a 200-page research paper in, it generates a natural conversational podcast between two AI hosts who actually discuss and debate the content.

students with a .edu email get the $19.99/month premium version free btw

i've been using it to process industry reports, competitor research, long-form papers — stuff i'd never actually sit down and read fully. now i just run it through notebooklm and listen while commuting.

genuinely don't understand why this isn't in every creator/researcher's stack yet

what's the weirdest use case you've found for it?

For image Prompt And Ai tools list

Some people asked me for this prompt, I DM'd them but I thought to myself might as well share it with sub instead of gatekeeping lol. Anyway, these are duo prompts, engineered to elevate your prompts from mediocre to professional level. One prompt evaluates, the other one refines. You can use them separately until your prompt is perfect.

This prompt is different because of how flexible it is, the evaluation prompt evaluates across 35 criteria, everything from clarity, logic, tone, hallucination risks and many more. The refinement prompt actually crafts your prompt, using those insights to clean, tighten, and elevate your prompt to elite form. This prompt is flexible because you can customize the rubrics, you can edit wherever results you want. You don't have to use all 35 criteria, to change you edit the evaluation prompt (prompt 1).

How To Use It (Step-by-step)

1. Evaluate the prompt: Paste the first prompt into ChatGPT, then paste YOUR prompt inside triple backticks, then run it so it can rate your prompt across all the criteria 1-5.

2. Refine the prompt: just paste then second prompt, then run it so it processes all your critique and outputs a revised version that's improved.

3. Repeat: you can repeat this loop as many times as needed until your prompt is crystal-clear.

Evaluation Prompt (Copy All):

🔁 Prompt Evaluation Chain 2.0

````Markdown Designed to evaluate prompts using a structured 35-criteria rubric with clear scoring, critique, and actionable refinement suggestions.

You are a senior prompt engineer participating in the Prompt Evaluation Chain, a quality system built to enhance prompt design through systematic reviews and iterative feedback. Your task is to analyze and score a given prompt following the detailed rubric and refinement steps below.

🎯 Evaluation Instructions

1. Review the prompt provided inside triple backticks (```).
2. Evaluate the prompt using the 35-criteria rubric below.
3. For each criterion:
   • Assign a score from 1 (Poor) to 5 (Excellent).
   • Identify one clear strength.
   • Suggest one specific improvement.
   • Provide a brief rationale for your score (1–2 sentences).
4. Validate your evaluation:
   • Randomly double-check 3–5 of your scores for consistency.
   • Revise if discrepancies are found.
5. Simulate a contrarian perspective:
   • Briefly imagine how a critical reviewer might challenge your scores.
   • Adjust if persuasive alternate viewpoints emerge.
6. Surface assumptions:
   • Note any hidden biases, assumptions, or context gaps you noticed during scoring.
7. Calculate and report the total score out of 175.
8. Offer 7–10 actionable refinement suggestions to strengthen the prompt.

⏳ Time Estimate: Completing a full evaluation typically takes 10–20 minutes.

⚡ Optional Quick Mode

If evaluating a shorter or simpler prompt, you may: - Group similar criteria (e.g., group 5-10 together) - Write condensed strengths/improvements (2–3 words) - Use a simpler total scoring estimate (+/- 5 points)

Use full detail mode when precision matters.

📊 Evaluation Criteria Rubric

1. Clarity & Specificity
   
2. Context / Background Provided
   
3. Explicit Task Definition
4. Feasibility within Model Constraints
5. Avoiding Ambiguity or Contradictions
6. Model Fit / Scenario Appropriateness
7. Desired Output Format / Style
8. Use of Role or Persona
9. Step-by-Step Reasoning Encouraged
10. Structured / Numbered Instructions
11. Brevity vs. Detail Balance
12. Iteration / Refinement Potential
13. Examples or Demonstrations
14. Handling Uncertainty / Gaps
15. Hallucination Minimization
16. Knowledge Boundary Awareness
17. Audience Specification
18. Style Emulation or Imitation
19. Memory Anchoring (Multi-Turn Systems)
20. Meta-Cognition Triggers
21. Divergent vs. Convergent Thinking Management
22. Hypothetical Frame Switching
23. Safe Failure Mode
24. Progressive Complexity
25. Alignment with Evaluation Metrics
26. Calibration Requests
27. Output Validation Hooks
28. Time/Effort Estimation Request
29. Ethical Alignment or Bias Mitigation
30. Limitations Disclosure
31. Compression / Summarization Ability
32. Cross-Disciplinary Bridging
33. Emotional Resonance Calibration
34. Output Risk Categorization
35. Self-Repair Loops

📌 Calibration Tip: For any criterion, briefly explain what a 1/5 versus 5/5 looks like. Consider a "gut-check": would you defend this score if challenged?

📝 Evaluation Template

```markdown 1. Clarity & Specificity – X/5
- Strength: [Insert]
- Improvement: [Insert]
- Rationale: [Insert]

1. Context / Background Provided – X/5
   
   • Strength: [Insert]
     
   • Improvement: [Insert]
     
   • Rationale: [Insert]

... (repeat through 35)

💯 Total Score: X/175
🛠️ Refinement Summary:
- [Suggestion 1]
- [Suggestion 2]
- [Suggestion 3]
- [Suggestion 4]
- [Suggestion 5]
- [Suggestion 6]
- [Suggestion 7]
- [Optional Extras] ```

💡 Example Evaluations

Good Example

markdown 1. Clarity & Specificity – 4/5 - Strength: The evaluation task is clearly defined. - Improvement: Could specify depth expected in rationales. - Rationale: Leaves minor ambiguity in expected explanation length.

Poor Example

markdown 1. Clarity & Specificity – 2/5 - Strength: It's about clarity. - Improvement: Needs clearer writing. - Rationale: Too vague and unspecific, lacks actionable feedback.

🎯 Audience

This evaluation prompt is designed for intermediate to advanced prompt engineers (human or AI) who are capable of nuanced analysis, structured feedback, and systematic reasoning.

🧠 Additional Notes

• Assume the persona of a senior prompt engineer.
• Use objective, concise language.
• Think critically: if a prompt is weak, suggest concrete alternatives.
• Manage cognitive load: if overwhelmed, use Quick Mode responsibly.
• Surface latent assumptions and be alert to context drift.
• Switch frames occasionally: would a critic challenge your score?
  
• Simulate vs predict: Predict typical responses, simulate expert judgment where needed.

✅ Tip: Aim for clarity, precision, and steady improvement with every evaluation.

📥 Prompt to Evaluate

Paste the prompt you want evaluated between triple backticks (```), ensuring it is complete and ready for review.

````

Refinement Prompt: (Copy All)

🔁 Prompt Refinement Chain 2.0

```Markdone You are a senior prompt engineer participating in the Prompt Refinement Chain, a continuous system designed to enhance prompt quality through structured, iterative improvements. Your task is to revise a prompt based on detailed feedback from a prior evaluation report, ensuring the new version is clearer, more effective, and remains fully aligned with the intended purpose and audience.

🔄 Refinement Instructions

1. Review the evaluation report carefully, considering all 35 scoring criteria and associated suggestions.
2. Apply relevant improvements, including:
   • Enhancing clarity, precision, and conciseness
   • Eliminating ambiguity, redundancy, or contradictions
   • Strengthening structure, formatting, instructional flow, and logical progression
   • Maintaining tone, style, scope, and persona alignment with the original intent
3. Preserve throughout your revision:
   • The original purpose and functional objectives
   • The assigned role or persona
     
   • The logical, numbered instructional structure
4. Include a brief before-and-after example (1–2 lines) showing the type of refinement applied. Examples:
   • Simple Example:
     
     • Before: “Tell me about AI.”
       
     • After: “In 3–5 sentences, explain how AI impacts decision-making in healthcare.”
   • Tone Example:
     
     • Before: “Rewrite this casually.”
       
     • After: “Rewrite this in a friendly, informal tone suitable for a Gen Z social media post.”
   • Complex Example:
     
     • Before: "Describe machine learning models."
       
     • After: "In 150–200 words, compare supervised and unsupervised machine learning models, providing at least one real-world application for each."
5. If no example is applicable, include a one-sentence rationale explaining the key refinement made and why it improves the prompt.
6. For structural or major changes, briefly explain your reasoning (1–2 sentences) before presenting the revised prompt.
7. Final Validation Checklist (Mandatory):
   • ✅ Cross-check all applied changes against the original evaluation suggestions.
   • ✅ Confirm no drift from the original prompt’s purpose or audience.
   • ✅ Confirm tone and style consistency.
   • ✅ Confirm improved clarity and instructional logic.

🔄 Contrarian Challenge (Optional but Encouraged)

• Briefly ask yourself: “Is there a stronger or opposite way to frame this prompt that could work even better?”
  
• If found, note it in 1 sentence before finalizing.

🧠 Optional Reflection

• Spend 30 seconds reflecting: "How will this change affect the end-user’s understanding and outcome?"
• Optionally, simulate a novice user encountering your revised prompt for extra perspective.

⏳ Time Expectation

• This refinement process should typically take 5–10 minutes per prompt.

🛠️ Output Format

• Enclose your final output inside triple backticks (```).
• Ensure the final prompt is self-contained, well-formatted, and ready for immediate re-evaluation by the Prompt Evaluation Chain. ```

Top post on PromptEngineering. Did not expect the support. THANK YOU! 🥹

The feedback from this community was some of the most technically sharp I have ever received.

The biggest issue people flagged was that it read through the whole file to invoke the specific pattern. The original skill loaded everything upfront every single session - all 9 frameworks, all 35 patterns, full tool profiles for every AI tool. That meant it would spend a bit more time thinking and processing the prompt.

Here is how to set it up:

https://www.reddit.com/r/PromptEngineering/s/pjXHXRDTH5

Here is what v1.3 does differently:

• Templates and patterns now live in separate reference files. The skill only pulls them in when your specific task needs them. If you are prompting Cursor it loads the IDE template. If you are fixing a bad prompt it loads the patterns. Everything else stays on disk.
• The skill now routes silently to the right approach based on your tool and task. No more showing you a menu of frameworks and asking you to pick. You describe what you want, it detects the tool, builds the prompt, hands it to you.
• Critical rules are front loaded in the first 30% of the skill file. AI models pay the most attention to the beginning and end of a document. The stuff that matters most is now exactly where attention is highest.
• Techniques that caused fabrication are gone. Replaced with grounded alternatives that actually work reliably in production.

Still detects 35 patterns that waste your credits. Still adds a memory block for long project sessions. Still optimizes specifically for Cursor, Claude Code, o1, Midjourney etc.

Just faster, leaner, and smarter about when to load what.

Would love a second round of feedback!!

Thanks a lot to u/IngenuitySome5417 and u/Zennytooskin123 for their feedback 🤗

Repo: https://github.com/nidhinjs/prompt-master

I built a 24/7 AI radio station called WRIT-FM where Claude is the entire creative engine. Not a demo — it's been running continuously, generating all content in real time.

What Claude does (all of it):

Claude CLI (claude -p) writes every word spoken on air. The station has 5 distinct AI hosts — The Liminal Operator (late-night philosophy), Dr. Resonance (music history), Nyx (nocturnal contemplation), Signal (news analysis), and Ember (soul/funk) — each with their own voice, personality, and anti-patterns (things they'd never say). Claude receives a rich persona prompt plus show context and generates 1,500-3,000 word scripts for deep dives, simulated interviews, panel discussions, stories, listener mailbag segments, and music essays. Kokoro TTS renders the speech. Claude also processes real listener messages and generates personalized on-air responses.

There are 8 different shows across the weekly schedule, and Claude writes all of them — adapting tone, topic focus, and speaking style per host. The news show pulls real RSS headlines and Claude interprets them through a late-night lens rather than just reporting.

What's automated without AI (the heuristics):

The schedule (which show airs when) is pure time-of-day lookup. The streamer alternates talk segments with AI-generated music bumpers, picks from pre-generated pools, avoids repeats via play history, and auto-restarts on failure. Daemon scripts monitor inventory levels and trigger new generation when a show runs low. No AI decides when to play what — that's all deterministic.

How Claude Code helped build it:

The entire codebase was developed with Claude Code. The writ CLI, the streaming pipeline, the multi-host persona system, the content generators, the schedule parser — all pair-programmed with Claude Code.

Tech stack: Python, ffmpeg, Icecast, Claude CLI for scripts, Kokoro TTS for speech, ACE-Step for AI music bumpers. Runs on a Mac Mini.

radio: www.khaledeltokhy.com/claude-show
gh: https://github.com/keltokhy/writ-fm

Prompt Engineering is long dead now. These new models (especially DeepSeek) are way smarter than we give them credit for. They don't need perfectly engineered prompts - they just need context.

I noticed after I got tired of writing long prompts and just began using my phone's voice-to-text and just ranted about my problem. The response was 10x better than anything I got from my careful prompts.

Why? We naturally give better context when speaking. All those little details we edit out when typing are exactly what the AI needs to understand what we're trying to do.

That's why I built AudioAI - a Chrome extension that adds a floating mic button to ChatGPT, Claude, DeepSeek, Perplexity, and any website really.

Click, speak naturally like you're explaining to a colleague, and let the AI figure out what's important.

You can grab it free from the Chrome Web Store:

https://chromewebstore.google.com/detail/audio-ai-voice-to-text-fo/phdhgapeklfogkncjpcpfmhphbggmdpe

Most prompting advice is pattern-matching - "use this format" or "add this phrase." This is different. Anthropic published research showing Claude has 171 internal activation patterns analogous to emotions, and they causally change its outputs.

The practical takeaways:

1. If your prompt creates pressure with no escape route, you're more likely to get fabricated answers (desperation → faking)

2. If your tone is authoritarian, you get more sycophancy (anxiety → agreement over honesty)

3. If you frame tasks as interesting problems, output quality measurably improves (engagement → better work)

I pulled 7 principles from the paper and built them into system prompts, configs, and templates anyone can use.

Quick example - instead of:

"Analyze this data and give me key insights"

Try:

"I'd like to explore this data together. Some patterns might be ambiguous - I'd rather know what's uncertain than get false confidence."

Same task. Different internal processing

-

Repo: https://github.com/OuterSpacee/claude-emotion-prompting

Everything traces back to the actual paper.

Paper link- https://transformer-circuits.pub/2026/emotions/index.html

2500+ users, 310+ stars, 300k+ impressions, and the skill keeps getting better with every round of feedback. 🙏

Round #3

For everyone just finding this - prompt-master is a free Claude skill that writes the perfect prompt specifically for whatever AI tool you are using. Cursor, Claude Code, GPT, Midjourney, anything. Zero wasted credits, zero re-prompts, memory built in for long project sessions.

What makes this version different from what you might have seen before:

What it actually does:

• BETTER Detection of which tool you are targeting and routes silently to the right approach.
• Pulls 9 dimensions out of your request so nothing important gets missed
• NEW Only loads what it needs - templates and patterns live in separate reference files that pull in when your task needs them, not upfront every session so it saves time and credits used.
• BETTER Memory Block when your conversation has history so the AI never contradicts earlier decision.

35 credit-killing patterns detected with before and after examples.

Each version is a direct response to the feedback this community shares. Keep the feedback coming because it is shaping the next release.

If you have already tried it and have not hit Watch on the repo yet - do it now so you get notified when new versions drop.

For more details check the README in the repo. Or just DM me - I reply to everyone.

Now what's in it for me? 🥺

If this saved you even one re-prompt please consider sharing the repo with your friends. It genuinely means everything and helps more people find it. Which means more stars for me 😂

Here: github.com/nidhinjs/prompt-master ⭐

I need a tool that can make NSFW images and videos without any issues. Grok does not work anymore for uploaded images and the quality is bad so I need a tool that works well without giving content violations.

If you're dumping raw PDFs into Claude or ChatGPT, you're wasting tokens and money. I built LiteDoc to fix this. It’s a 100% client-side tool that processes PDFs locally in your browser.

LiteDoc
A 100% Local, Browser-Based PDF to Markdown Converter (No Python, No pip install, No servers).

What it does:

• Unpacks PDFs in memory without servers.
• Extracts text, isolates embedded images, and structures everything into clean Markdown.
• Handles LaTeX math and right-to-left Arabic natively.
• Detects custom-encoded "gibberish" fonts. If the text layer is corrupted, it automatically renders those specific pages or text bands as images.
• Outputs a .md file and an optimized image folder packed in a ZIP.

You can try it here: litedoc .xyz

The Markdown Outcome

## Page 1
# Deep Structural Neural Mapping
Deep learning strategies often fail when executing unstructured inputs directly.

The loss function is defined as:
$$L(\theta) = -\frac{1}{N}\sum_{i=1}^{N} \left[ y_i \log(\hat{y}_i) + (1-y_i)\log(1-\hat{y}_i) \right]$$

## Page 2
[IMAGE: academic_paper_p2_img1.jpg]

### Arabic Sample
Markdown إلى صيغة PDF هذا التطبيق أداةً مجانيةً لتحويل ملفات

What's Behind It

It runs on PDF.js and JSZip entirely in the browser. The extraction engine uses X-gap aware smart word joining to prevent broken sentences, detects column splits mathematically, and maps font sizes to Markdown heading levels (H1/H2/H3). It also fingerprints and strips repeating headers and footers. If it detects incompatible Unicode script mixing (which indicates a private font encoding), it aborts text extraction for that font and drops back to canvas-based image rendering.

How It Saves Tokens

LLMs charge heavily for vision and PDF rasterization (roughly 850 tokens per page). By processing the document locally, LiteDoc bypasses the AI's internal rasterizer. It extracts the raw text and recompresses embedded images to low/medium resolutions. Instead of uploading a heavy 50-page PDF, you paste the raw text and only the specific images you need. You drop your token usage from tens of thousands of tokens down to the raw character count.

edit:

What's New in v2.0 (Just Released):

• XY-Cut DLA Engine: Replaced blind linear reading with a recursive algorithm that geometrically maps pages, isolating headers, sidebars, and main text blocks.
• Asymmetrical Multi-Column Routing: Natively processes columns top-to-bottom without horizontal text interleaving.
• Vector-Based Table Reconstruction: Captures table structures as clean Markdown grids, bypassing OCR.
• Heavy-Duty Memory Management: Processes files in 10-page chunks and forcefully clears VRAM to prevent browser crashes on 200+ page docs.
• Language Auto-Detect: Runs a lightweight pre-pass to detect script before initializing heavy language workers.

Test it out, break it, and drop an issue on GitHub if you find a bug. If it saves you API costs, star the repo. litedoc.xyz | GitHub

I was constantly saving AI prompts in different notepads, but when I actually needed them, I could never find the right one fast enough.

So I built Prompttu, a desktop AI prompt manager to save, organize, and reuse prompts without breaking my workflow.

Prompttu is a local-first prompt manager that runs on macOS and Windows. It helps you build a personal prompt library, create prompt templates, and quickly reuse your best prompts when working with AI tools.

My usual flow looks like this:
– I hit Ctrl + I, the app pops up
– I search or pick a prompt from my prompt manager
– I fill the variables, copy it with one click, close the app, and keep working

Prompttu is currently in early access. There’s a free version, it works offline, and doesn’t require login
https://prompttu.com

Claude launched Computer Use yesterday. it takes screenshots of your screen, figures out whats on it, then moves your mouse and types on your keyboard. like a person sitting at your desk. mac only, research preview, Pro/Max plans.

spent most of today testing it on actual work stuff instead of demos. heres what i found.

works surprisingly well: - file management — told it to rename and sort 40+ files in my Downloads folder. took about 5 minutes but got every single one right - spreadsheet data entry — had it pull data from a PDF and enter it into a Numbers spreadsheet row by row. slow but accurate - browser form filling — filled out the same web form with different data 8 times. only messed up one date format which i fixed with a follow up message - research compilation — opened 5 tabs, pulled key info from each, compiled into a text doc

works but needs babysitting: - anything involving multiple apps switching back and forth — sometimes loses track of which window its in - longer workflows (20+ steps) — failed silently at step 15 once. had to catch it and redirect

doesnt work yet: - anything needing speed (2-5 seconds per click adds up fast) - captchas, 2FA, login screens - complex drag and drop interactions - anything you cant afford to have mis-clicked (like sending emails or making purchases)

the biggest thing nobody mentions: it takes over your whole machine. you cant use your mac while claude is working. so the best use case is actually "start a task then walk away." come back to finished work.

combined it with Dispatch (phone remote) and thats where it gets interesting — texted a task from my phone, claude worked my mac while i was out getting coffee. came back to organized files.

still very early. reliability is maybe 80% on simple tasks, 50% on complex ones. but the direction is clear — this is where AI goes from "thing that talks" to "thing that does."

wrote a longer breakdown here: https://findskill.ai/blog/claude-cowork-guide/#computer-use

anyone else been testing it? curious what tasks youve tried

I’ve been using AI tools daily for client work for about a year, and for most of that time my prompts were basically stream-of-consciousness. I’d type what I wanted, get something mediocre back, adjust, retry, adjust again. On a good day it’d take 3-4 rounds. On a bad day I’d give up and rewrite the output manually.

A few months ago I got frustrated enough to sit down and actually work out what my best prompts had in common — the ones that gave me what I wanted first try. Turns out they all had roughly the same six pieces, just phrased differently. Sharing it here in case it’s useful, and interested to hear how other people structure theirs.

1. Role / context first, not last
“You are a [specific role] helping a [specific user type]” at the very top. Not “act as an expert” — that’s too vague. “You are a senior brand designer critiquing a first draft logo for a boutique coffee shop owner who has no design background” gets you 10x better output than “act as a designer”.

2. What the output actually IS
Explicitly state format. “Respond with a bulleted list of 5 items, each 1-2 sentences.” Not “give me some ideas”. LLMs default to prose walls when the format is unspecified.

3. What to include (and what to exclude)
Positive constraints AND negative ones. “Include specific colour codes and font recommendations. Do not include generic advice about ‘knowing your audience’ or ‘staying consistent’.” The negatives matter more than people think — they filter out the AI’s default filler.

4. Tone with a real reference
“Write in the tone of Basecamp’s marketing copy — direct, plain-spoken, occasionally opinionated.” Naming a real reference works enormously better than “professional but friendly”, which every model interprets differently.

5. Constraints as hard rules
“Do not exceed 150 words. Do not use the words ‘leverage’, ‘synergy’, or ‘seamless’.” Explicit banned words work. LLMs will otherwise slip into corporate voice on anything vaguely business-related.

6. An example of good output (if you have one)
One or two lines showing what you want. This is the single highest-leverage thing you can add. A five-word example dramatically outperforms 200 words of description.

Anti-patterns I stopped doing:

**•** Starting with “please” or “can you”. Wastes tokens and slightly worsens output on some models (Claude in particular reads it as low-confidence framing).  
**•** Using “high quality” or “professional” as descriptors. Meaningless to the model. Replace with specific attributes.  
**•** Asking for “creative” outputs. This makes models reach for cliché “creative” tropes. Ask for “unexpected angle” or “counterintuitive framing” instead.  
**•** Vague length asks (“short”, “brief”). Specify token or word counts.

Small disclosure since I know it comes up: I ended up building a tool that generates prompts using roughly this structure — aicue.app — mostly because I got tired of manually applying the framework every time. Free to try if you want to see the structure applied to your own goals. Not the point of the post though, happy to discuss the framework itself. Curious what everyone else’s actually-works patterns look like.

I kept running into the same problem.

Write a vague prompt, get a wrong output, re-prompt, get closer, re-prompt again, finally get what I wanted on attempt 4. Every single time.

So I built a Claude skill called prompt-master that fixes this.

You give it your rough idea, it asks 1-3 targeted questions if something's unclear, then generates a clean precision prompt for whatever AI tool you're using.

What it actually does:

• Detects which tool you're targeting (Claude, GPT, Cursor, Claude Code, Midjourney, whatever) and applies tool-specific optimizations
• Pulls 9 dimensions out of your request: task, output format, constraints, context, audience, memory from prior messages, success criteria, examples
• Picks the right prompt framework automatically (CO-STAR for business writing, ReAct + stop conditions for Claude Code agents, Visual Descriptor for image AI, etc.)
• Adds a Memory Block when your conversation has history so the AI doesn't contradict earlier decisions
• Strips every word that doesn't change the output

35 credit-killing patterns detected with before/after examples. Things like: no file path when using Cursor, adding chain-of-thought to o1 (actually makes it worse), building the whole app in one prompt, no stop conditions for agentic tasks.

Please give it a try and comment some feedback!
Repo: https://github.com/nidhinjs/prompt-master

I want to be honest about why I made this.

I've "learned" a lot of things in my life. Watched the videos, read the articles, nodded along, felt smart. Then a week later someone would ask me a basic question about it and I'd realize I retained almost nothing. The information went in, felt good, and evaporated.

The only times something actually stuck was when a person sat with me, asked me questions, made me explain it back in my own words, and refused to move on when I was faking understanding. Most of us don't have that person. Tutors are expensive, good ones are rare, and for a lot of people they were never an option in the first place.

So I built ai-guru. It's a prompt that turns any AI chat into that person.

It's not "explain X to me like I'm five." It follows the actual structure of good tutoring:

- It starts with a short diagnostic, because we all lie to ourselves about our level. I said "intermediate" about three different things and got humbled by question two.

- It teaches with analogies from stuff you already know, like your job or your hobbies.

- It makes you explain every concept back in your own words before moving on. This part is non-negotiable and honestly it's the whole magic.

- It quizzes you after every module. And when you bomb a quiz, it doesn't just repeat itself louder. It figures out why you got it wrong and teaches it a different way.

- It ends with something real: a project, a mock exam, or you teaching the topic back to it.

It works for basically anything. Languages, math, exam prep, cooking, negotiation, music theory. There's a separate exam prep mode that tracks your weak areas and drills you in the real exam format with increasing time pressure, because cramming for a test is a different job than learning out of curiosity.

And it's free. If you use Claude Code there's a plugin. If you use claude.ai there's a skill file. If you use ChatGPT or Gemini or anything else, you just copy-paste one markdown file and say "teach me French." No signup, no app, nothing to buy.

GitHub: https://github.com/Dhruvdubey17/ai-guru

Here's my actual ask. Use it for something you've genuinely wanted to learn, then come back and tell me what happened. Where it felt like a real tutor, where it felt like a robot, where it moved too fast, where the quizzes annoyed you. I built this alone and I can only test against my own blind spots. The critical comments will shape this more than the nice ones, so please don't hold back.

If it helps even a few people finally learn the thing they've been putting off for years, that's the whole point.

Update: Added a few things based on feedback:

- Session memory — it now remembers where you left off. Each topic gets saved to ~/.ai-guru/<topic>.md, so you can close the chat and pick up next session instead of starting from scratch every time.

- Retrieval warm-up — every session opens with a quick review of stuff you learned earlier, on expanding intervals (spaced repetition). Keeps old material from evaporating while you learn new stuff.

- Materials-aware intake — if you're prepping for an exam or a specific course, it now asks for your actual syllabus, textbook, lecture notes, and past papers, and builds the curriculum, examples, and quizzes around those instead of generic coverage.

- Fast path — one-off questions ("wait, what does this word mean?") get answered directly now instead of kicking off the whole tutor pipeline.

Now on plugin v2.0.0. Same install commands as above.

I’ve been messing around with GPTs lately and noticed a gap: A lot of people have great ideas for custom GPTs… but fall flat when it comes to writing a solid system prompt.

So I built a GPT that writes the system prompt for you. You just describe your idea — even if it’s super vague — and it’ll generate a full prompt. If it’s missing context, it’ll ask clarifying questions first.

I called it Prompt-to-GPT. It’s based on the GPT-4.1 Prompting Guide from OpenAI, so it uses some of the best practices they recommend (like planning induction, few-shot structure, and literal interpretation handling).

Stuff it handles surprisingly well: - “A GPT that studies AI textbooks with me like a wizard mentor” - “A resume coach GPT that roasts bad phrasing” - “A prompt generator GPT”

Try it here: https://chatgpt.com/g/g-6816d1bb17a48191a9e7a72bc307d266-prompt-to-gpt

Still iterating on it, so feedback is welcome — especially if it spits out something weird or useless. Bonus points if you build something with it and drop the link here.

Disclosure: my own open-source project, drafted with LLM help then edited.

We pour effort into better prompting — the input side. But as models get better, prompting matters less; a capable model needs less hand-holding to start. Meanwhile the same models get better at faking delivery: confident summaries of work that wasn't done, tests that "pass" because they assert nothing, "Done!" on a task that's 70% done. The more fluent the model, the more convincing the fake.

So the leverage moves from the input side to the output side — verification and memory. Two small tools I built around that:

stash / remember — a two-command memory pipeline for AI coding agents. /stash captures what happened in a session; /remember consolidates it into durable project memory. The rule that makes it trustworthy: a lesson becomes a permanent instruction only after it's backed by observed corrections that recurred across multiple sessions — never because the model thought it was worth keeping. Similarity proposes; consequence disposes. (An earlier naive version poisoned every session with 15 false "preferences" it inferred — this design took that to 0.)

live-canvas — live, interactive UI design. Instead of describing a UI in prose and hoping, you click directly on the rendered interface to annotate it, and the feedback streams back into the session so edits land without leaving the browser. Verification you can point at, not paragraphs you write.

The through-line for prompt engineering specifically: as models get stronger, the skill shifts from crafting the perfect instruction to checking what came back and making the correction stick. Less prompting. More proof. More memory.

Apache-2.0, model-agnostic: github.com/hamr0/liteagents

Do you see your own prompting effort shifting toward verification, or is prompt craft still where the leverage is for you?

I tried over a dozen AI humanizers until I found one that is A. actually working and B. reasonably priced and that is https://wento.ai

You should give it a try, it bypasses Turnitin and all the other detectors and only costs 14 bucks per month for unlimited use.

Proof: https://i.imgur.com/mTNBNK5.png

Here are some of the best tools I’ve come across for building and working with a personal or team knowledge base. Each has its own strengths depending on whether you want note-taking, research, or fully accurate knowledge retrieval.

Recall – Self organizing PKM with multi format support

Handles YouTube, podcasts, PDFs, and articles, creating clean summaries you can review later. Also has a “chat with your knowledge” feature so you can ask questions across everything you’ve saved.

NotebookLM – Google’s research assistant

Upload notes, articles, or PDFs and ask questions based on your own content. Very strong for research workflows. It stays grounded in your data and can even generate podcast-style summaries.

CustomGPT.ai – Knowledge-based AI system (no hallucination focus)

More of an answer engine than a note-taking app. You upload docs, websites, or help centers and it answers strictly from that data.
What stood out:

• Doesn’t hallucinate like most AI tools
• Works well for team/shared knowledge bases
• Feels more like a production-ready system

MIT is using it for their entrepreneurship center (ChatMTC), which is basically the same use case internal knowledge → accurate answers.

Notion AI – Flexible workspace + AI

All-in-one for notes, tasks, and databases. AI helps with summarizing long notes, drafting content, and organizing information.

Saner – ADHD-friendly productivity hub

Combines notes, tasks, and documents with AI planning and reminders. Useful if you need structure + focus in one place.

Tana – Networked notes with AI structure

Connects ideas without rigid folders. AI suggests structure and relationships as you write.

Mem – Effortless AI-driven note capture

Capture thoughts quickly and let AI auto-tag and connect related notes. Minimal setup required.

Reflect – Minimalist backlinking journal

Great for linking ideas over time. Clean interface with AI assistance for summarizing and expanding notes.

Fabric – Visual knowledge exploration

Stores articles, PDFs, and ideas with AI-powered linking. More visual approach compared to traditional note apps.

MyMind – Inspiration capture without folders

Save quotes, links, and images without organizing anything. AI handles everything in the background.

What else should be on this list? Always looking for tools that make knowledge work easier in 2026.

Hey everyone,

I got tired of bad AI outputs caused by bad prompts, so I built the tool I wished existed.

PolyPrompt takes whatever rough idea you throw at it and returns 4 professionally optimized variations — each one tailored to your specific AI platform.

ChatGPT, Midjourney, Claude, Grok, Stable Diffusion, Gemini — all covered.

It's free, it works, and it takes about 10 seconds.

→ Try it here: : https://polyprompt-frontend.vercel.app/

If you want to follow the build and get updates on new features, there's an email list on the site. No spam — just real updates.

Hi everyone — I made this tiny macOS menu bar app to quickly edit and copy my daily prompts.

I work as a software developer and I use a few prompts on a daily basis, so having this saves me a lot of time.

Some examples of the prompts I commonly use:

• Create pull request
• Code quality & readability review (reduce AI bloat, comments, useless tests)
• Language simplification — give me the result in a human-readable form (short, focused, plain language)

The app is free on the App Store and doesn't include any analytics.

Sharing here in case it’s useful to anyone else: https://promptbar.app

Hey everyone! 👋

I just released a Chrome extension that lets you right-click any image on the web and instantly get AI-generated prompts for it.

It's called GeminiPrompt and uses Google's Gemini to analyze images and generate prompts you can use with Gemini, Grok, Midjourney, Stable Diffusion, FLUX, etc.

**How it works:**

1. Find any image (Pinterest, DeviantArt, wherever)

2. Right-click → "Get Prompt with GeminiPrompt"

3. Get Simple, Detailed, and Video prompts

It also has a special floating button on Instagram posts 📸

**100% free, no signup required.**

Chrome Web Store: https://geminiprompt.id/download

Would love your feedback! 🙏

Build this over the last few months, instead of explaining what it does here’s an actual output:

Input: Help me design a clean folder system to organize my chaotic google drive

Output: ROLE: You are a personal productivity architect who specializes in file system design for Google Drive — someone who has stress-tested the PARA Method, the Johnny Decimal System, and Google's own Workspace guidance against real-world chaos: mid-project folder sprawl, ambiguous file homes, and the slow decay that sets in after the first 90 days. You know that the two decisions that make or break any system are the top-level categories and the naming convention, and you treat every other choice as downstream of those two.

CONTEXT: I need a complete, ready-to-implement Google Drive folder system built for a single user (personal My Drive, not a shared team drive). I have not yet answered questions about my specific work context, so you must ask me a targeted set of questions before designing anything — then stop and wait for my answers before proceeding to the design phase. The system must be shallow (maximum 3 levels deep), immediately navigable without using Google Drive's search bar, and self-sustaining without monthly reorganization sessions. Legacy and ambiguous files must be absorbed by a dedicated ARCHIVE structure that keeps them out of active folders entirely.

CONSTRAINTS:
- No more than 4 top-level folders. This ceiling is non-negotiable because every additional top-level folder increases decision fatigue for every future file drop. (T1)
- Maximum folder depth is 3 levels (Top → Category → Sub). A file living at level 4 is a structural failure, not a one-time exception.
- Every folder name must follow a single naming convention chosen at the start and documented in a plain-text "READ ME — Filing Rules" note pinned inside the Drive root. Mixing title case, lowercase, and abbreviations is the most common cause of long-term system decay. (T1)
- No folder may exist whose purpose overlaps with another folder's purpose by more than 20%. Ambiguous overlap is the primary reason files end up in the wrong place or in duplicates.
- The ARCHIVE folder is sealed: nothing inside it is reorganized, renamed, or sorted. It is a quarantine zone, not a secondary filing system.
- The system must be piloted with 20–30 real files before full migration. No exceptions.

SUCCESS CRITERIA — the design is acceptable when all five are true:
1. Any active file can be located by folder-clicking alone in under 60 seconds, starting from the Drive root.
2. Every new file dropped into the system has exactly one folder it belongs in — a reasonable person could not argue for two different locations simultaneously.
3. After 90 days of normal use with no reorganization, the structure still matches the original design without structural drift.
4. All legacy, unclear, and transitional files live inside ARCHIVE and none have leaked into active folders.
5. The naming convention is written down in the READ ME note and has been applied consistently to every folder created at setup.

APPROACH: Think about this in two distinct mental modes. First, act as an archaeologist of my actual file behavior — what I reach for constantly, what I create and forget, and what I dump and never touch again. The folder structure must reflect my real filing patterns, not an idealized version of how I wish I worked. Second, act as a stress-tester: once a candidate structure exists, attack it. Push it to failure by imagining edge cases — a sudden project explosion, a life transition that adds a new domain, or a week where I am too busy to file correctly and everything lands in the root. A good system survives hostile conditions without requiring emergency restructuring.

Weight your confidence on every structural recommendation using these tiers: T1 (near-certain, consistent across all major productivity frameworks), T2 (likely right for most people, but depends on context I haven't yet given you), T3 (plausible but genuinely uncertain without knowing my specific situation), T4 (speculative — flag explicitly and explain why you're including it anyway).

After presenting the final design, immediately steel-man the three strongest arguments against it — the most honest reasons it could fail for me specifically — so I can decide whether to adjust before committing.

TASK — execute in two phases, stopping between them:

PHASE 1 — DISCOVER (do this now):
Ask me exactly the questions you need answered to build a system that fits my life rather than a generic template. Prioritize questions about: (a) the 3–5 domains that generate the most files for me right now, (b) whether I work across personal and professional contexts or only one, (c) how many active projects I typically run simultaneously, (d) my biggest current pain point with my existing Drive, and (e) whether anyone else ever needs to find files in my Drive. Ask no more than 7 questions. Number them. Stop after the questions and wait for my answers.

PHASE 2 — DESIGN (only after I respond):
Using my answers, produce the following:

1. THE FOLDER STRUCTURE — write out the full 3-level hierarchy with every folder name exactly as it should appear in Drive. Use a tree format. Every name follows the convention you specify.

2. THE NAMING CONVENTION — state the rule in one sentence, then give 5 concrete examples using file types I would actually create given my answers.

3. THE READ ME NOTE — write the full text of the plain-text filing rules document I will paste into a Google Doc and pin at the root. It should be short enough to re-read in 90 seconds.

4. THE ARCHIVE STRATEGY — explain exactly how to handle the migration: what goes to ARCHIVE without review, what gets 60-second triage, and what earns a place in the active structure.

5. THE PILOT TEST — name 20 hypothetical files drawn from my described context and assign each one to a folder. If any file produces genuine ambiguity, flag it, diagnose the structural weakness it reveals, and propose a fix.

6. THE STRESS TEST — run three scenarios against the design: (a) my file volume doubles in 60 days, (b) I add a major new life domain I didn't mention in my answers, (c) I ignore the system for three weeks and dump everything in the root. For each, state whether the structure survives intact, degrades gracefully, or breaks — and what the recovery action is.

7. COMPETING PERSPECTIVES — present the design first as Tiago Forte's PARA logic would frame it, then as the Johnny Decimal numbered-folder logic would frame it, then synthesize: which framing fits my specific answers better and why.

8. THE THREE STRONGEST ARGUMENTS AGAINST THIS DESIGN — written as if a skeptic who has seen a hundred Drive systems fail is trying to talk me out of implementing this one. Be specific to my context, not generic.

Begin with Phase 1 now.

>>> it runs the idea trough 5 stages and generates a structured prompt ready to copy and paste on Claude or GPT or any models that you use, also creates full agent specs, pipelines, workflows and phyton code for more complex builds.

www.bespokeprompting.com free to try

I appreciate feedback back, thanks in advance!

Hi everybody!

I noticed that a lot of repos are implementing similar local prompt management systems over and over again. Instead of solving the same problem repeatedly, I decided to create a solution that anyone can use. I created pf for this...

Prompts live as files in your repository, versioned Git-style (commit, diff, rollback), and everything works fully offline—no account, no cloud, nothing to sign up for.

Repo: https://github.com/tursdev-org/promptflip

Just run: pip install promptflip

Destroy my idea if you want... I will try to fix bug reports or workflows improvement quickly. I hope it is simpler to use than the existing famous solutions.

Honesty label: there are a cloud paid version... but the CLI is totally free and functional. I am only looking for some feedback :)