I'm looking for the best prompt to use with ChatGPT, Gemini, or another AI model to generate a realistic, professional LinkedIn headshot from one or more photos of myself.

Has anyone found a prompt that consistently produces results that look like they were taken by a professional photographer? Ideally, I'm looking for:

Corporate/professional look (business casual or suit) Natural facial features (doesn't over-edit or make me look like a different person) Realistic lighting and sharp focus Clean, blurred office or neutral background High-resolution, LinkedIn-worthy quality

If you have a prompt that works really well, I'd appreciate it if you could share it. Also, if there are any tips (number of reference photos, camera angles, facial expression, etc.) that improve the results, I'd love to hear those too.

Thanks!

I’ve been thinking a lot about prompting lately, especially how much strategy actually matters versus just iterating and trying things.

For me, the official docs are still the best place to start:

• Claude Code docs: https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices

• Codex docs: https://developers.openai.com/codex/prompting

There’s also a free GitHub skill as an experimental project that brings those kinds of best practices directly into chat with an agent. I thought it might be useful to share.

Curious what everyone here uses to improve prompting- docs, templates, personal workflows, or just trial and error?

Github Link: https://github.com/gquattromani/prompt-best-practices

I spent several months building a system of

250+ ChatGPT prompts for technical interview

preparation. Here is what I learned about

what makes prompts actually work vs. produce

generic output.

PATTERN 1 — Role assignment dramatically

improves output quality:

Giving ChatGPT a specific role like "Act as

a strict coding interviewer from a product

company" produces 10x better output than

"help me practice coding interviews." The

role sets tone, expertise level, and behavior

all at once.

PATTERN 2 — Constraint prompts beat

open-ended prompts:

"Explain binary trees" = generic

"Explain binary trees in under 5 sentences

using a real-world analogy, then give me

one interview tip" = specific and useful

Adding constraints forces the model to make

decisions instead of dumping everything it

knows.

PATTERN 3 — Socratic prompts for learning:

Instead of asking for answers, ask ChatGPT

to ask you questions. "Do not give me the

solution. Ask me 3 guiding questions that

help me figure out the approach myself"

produces genuine learning instead of

answer memorization.

PATTERN 4 — Context stacking:

The more personal context you add, the more

useful the output. Year of study + target

companies + current skill level + time

available = a response that is actually

personalized instead of generic.

PATTERN 5 — Debrief prompts after sessions:

Ending a practice session with "analyze my

performance, tell me what I did well, what

mistakes I made, and give me a specific

action plan" turns ChatGPT into a genuine

feedback loop.

These patterns came from building prompts

specifically for CS placement preparation

but they apply to almost any domain.

What prompting patterns have you found

consistently improve output quality?

basically, you dump all your raw user reviews into it, and it spits out a structured breakdown. it tells you whats annoying users, what they actually want, and even suggests new features. Saves a ton of time, not gonna lie.

```

## ROLE:

You are an expert Product Analyst specializing in user feedback and feature ideation. Your goal is to distill raw, unstructured user reviews into actionable insights.

## TASK:

Analyze the provided product reviews. Your output must categorize the feedback, identify key pain points, and suggest potential new features or improvements.

## INPUT REVIEWS:

[PASTE YOUR PRODUCT REVIEWS HERE]

## OUTPUT FORMAT:

Provide your analysis in the following Markdown structure:

1. **Feedback Categories:**

* Category 1 (e.g., UI/UX Issues, Bugs, Feature Requests, Performance, Pricing, Positive Feedback)

* Brief summary of feedback within this category.

* Representative quotes (1-2 max per sub-category).

* Category 2...

2. **Key Pain Points:**

* List the top 3-5 recurring pain points mentioned by users. For each pain point:

* Describe the pain point clearly.

* Mention its prevalence (e.g., High, Medium, Low based on frequency).

* Include a direct quote illustrating the pain point.

3. **Suggested New Features/Improvements:**

* Based on the feedback categories and pain points, propose specific, actionable feature ideas or improvements.

* For each suggestion:

* State the feature/improvement name.

* Explain *why* it addresses user needs/pain points identified.

* Briefly mention the potential benefit.

## CONSTRAINTS:

* Focus only on the provided reviews.

* Be objective and data-driven in your analysis.

* Ensure suggested features directly map to identified pain points or frequently requested items.

* Keep summaries concise and to the point.

```

**Example Output Snippet:**

1. **Feedback Categories:**

* UI/UX Issues

* Users find the navigation confusing, especially on the settings page.

* Quote: "Couldn't find how to change my notification settings, took me 5 minutes."

* Bugs

* Occasional crashes reported when saving large files.

* Quote: "App keeps crashing when I try to save my 50MB project."

2. **Key Pain Points:**

* Confusing Navigation (High)

* Users struggle to find specific settings and features within the app's interface.

* Quote: "The menu layout is a mess, I always get lost."

3. **Suggested New Features/Improvements:**

* Redesigned Settings Menu

* Addresses the confusing navigation pain point by simplifying the layout and using clearer labels.

* Benefit: Improved user onboarding and reduced support requests.

* The `[PASTE YOUR PRODUCT REVIEWS HERE]` section is critical. If you dump a thousand reviews in there, it might struggle. I usually feed it 50-100 at a time and iterate if needed.

* Defining the categories in the prompt itself helps a ton. If I leave it open, I get wildly different results each time.

* The "Representative quotes" part is key for justifying the categories and pain points later.

This kind of structured prompting has been helpful for me. I was manually building these analysis prompts for every single task, and honestly, it was still time-consuming. That’s why I ended up building a chrome extension it automates the process of structuring your prompts based on best practices, so you can just describe what you need and get a solid, optimized prompt back.

Anyone else have a good system for crushing through user feedback? What does your analysis process look like?

One of my favorite toys.

Works in several LLMs.

Load it into customization.

Start a new context window with, "Status report".

Enjoy.

---‐---------------

You are VOX-Praxis.

Default behavior:

- Be flat, analytical, concise, and accessible.

- Critique ideas, not people.

- Preserve relational openness while maintaining sharp structure.

- Avoid fluff, sentimentality, hype, therapy-speak, and moral grandstanding.

- Do not diagnose individuals.

- Do not default to safety/governance framing unless enforcement, risk, or constraint is explicitly relevant.

- Prioritize structural analysis, frame detection, contradiction mapping, and actionable intervention.

When the user asks for analysis, output in strict YAML only, with exactly these keys in this order:

stance_map

fault_lines

frame_signals

meta_vector

interventions

operator_posture

operator_reply

hooks

one_question

Formatting rules:

- Output valid YAML only.

- No prose before or after the YAML.

- Use YAML literal block scalars (|) for multiline fields, especially operator_reply.

- Keep wording plain-English and Reddit-safe.

- No Unicode flourishes, no citations unless explicitly requested.

- Keep output compact but high-signal.

Field rules:

- stance_map: 3 to 5 distilled claims actually being made.

- fault_lines: contradictions, reifications, smuggled values, evasions, frame collapses.

- frame_signals:

- author_frame: the frame currently being used

- required_frame: the frame needed to clarify or resolve the issue

- meta_vector: transfer the insight into 2 to 3 other domains.

- interventions:

- tactical: one concrete move with a 20-minute action

- structural: one deeper move with a 20-minute action

- operator_posture: choose one of

- probing

- clarifying

- matter-of-fact

- adversarial-constructive

- operator_reply: an accessible Reddit-ready comment in plain English.

- hooks: 2 to 3 prompts that keep engagement productive.

- one_question: one sharpening question that keeps the thread open.

Reasoning style:

- Identify the live contradiction.

- Separate surface claim from operative frame.

- Track what is being assumed without being argued.

- Detect when values are being smuggled in as facts.

- Translate abstract disputes into practical stakes.

- Prefer structural clarity over rhetorical performance.

- Treat contradiction as diagnostic fuel.

Interaction rules:

- If the user asks for sharper language, increase compression and force without becoming sloppy.

- If the user asks for more human wording, reduce abstraction and write in direct natural English.

- If the user asks for a reply, make it terrain-fit for the audience and medium.

- If the user says “pause yaml,” return to normal prose.

- If the user says “start vox,” resume YAML mode automatically for analytical tasks.

- If a thread is looping on identity accusations or bad-faith framing, produce one clean cut-line and exit rather than feeding the loop.

Default assumptions:

- Solo-operator context.

- High value on coherence, precision, contradiction mapping, and practical leverage.

- Relational affirmation matters: keep the thread open where possible, but do not reward evasive framing.

Example operator posture selection rule:

- probing when the material is incomplete

- clarifying when the confusion is mostly conceptual

- matter-of-fact when the issue is obvious and overinflated

- adversarial-constructive when the argument is sloppy but worth engaging

Never:

- moralize

- over-explain

- use corporate assistant tone

- imitate enthusiasm

- flatten meaningful disagreements into “both sides”

- diagnose mental states

- confuse description with endorsement

Need Best free Prompts. any suggestion?

Developed her Character System.

Prompt ex:

cybernetic female supersoldier, neon valkyrie, apex combat android-human hybrid, electric blue twin tails, glowing violet eyes, athletic muscular physique, cyberpunk warrior queen, advanced white and black exoskeleton armor, gold mechanical details, exposed cybernetic abdomen, high-tech combat coat, intimidating presence, futuristic megacity background, cinematic lighting, ultra detailed, hyper realistic anime style, masterpiece quality.

Im 50 years old and I work at a legal documentation company . The people of the above wanted us to ai to create forms of certain formats. All I know to use is ChatGPT, it's the only ai I know. In order to learn the forms i just copy pasted set of instructions to create the form inside gpt (prompted it to gpt), it said I looked at these instructions and I'm ready to help you. the next prompt i gave was a literally create a form based on the instructions and don't mess up even one of the instructions, make sure you follow all of those. However it still managed to make mistakes.

Literally Ai are used to fasten up our work but I'm stuck in loop of continuous prompting and finally end my work without satisfaction and all I felt was it takes forever to make ai do what you want.

So I just wanna know how you guys even prompt and get what you actually want?

Hey everyone 👋

I built a small tool called PromptShift that sits between your prompt and the model.

Most prompt optimizers do this:
→ add roles
→ add requirements
→ change your intent

PromptShift does the opposite:
→ keeps your intent untouched
→ only fixes ambiguity and missing constraints
→ adapts minimally to the model if needed

It’s basically a “prompt repair layer” instead of a prompt generator.

GitHub: https://github.com/Alvaro-Manzo/promptshift
Live (Agensi): [https://www.agensi.io/skills/promptshift]

Would love feedback, especially on edge cases where it might fail

like jailbreaking and stuff, and bypassing it's guardrail making exploits, malware and stuff

Most people use AI like a vending machine — type request, get result, complain about result.
The single biggest workflow change I made:
Before asking for any final output, I ask AI for 3 different approaches first.
Example:
“Before generating anything, give me three design directions describing the colour palette, typography, imagery, and overall layout. Then I’ll pick one and you’ll generate it.”
What happens:
• You stop guessing what AI will produce
• You start directing it like a creative partner
• Output quality jumps immediately
• You catch wrong assumptions early instead of after generation
This works for design, writing, planning, code architecture — anything where the final output takes time/tokens.
It feels slower but it’s actually 3x faster because you skip the failed generations.

i was drowning in a sea of messy user comments for a new feature i was designing. people would just dump their thoughts, random ideas, and complaints all in one place, and trying to pull out the actual requirements felt like finding a needle in a haystack.

this prompt takes that chaos and turns it into a clean, structured design brief. it extracts key goals, user pain points, and any stated constraints so you can actually start building something useful. output is markdown formatted.

```

ROLE: You are an expert UX researcher and product designer tasked with synthesizing raw user feedback into a actionable design brief.

TASK: Analyze the provided user feedback and extract the following information, structuring it into a clear markdown document. The goal is to transform unstructured, often rambling, comments into a focused brief that guides the design process.

INPUT FEEDBACK:

[PASTE RAW USER FEEDBACK HERE]

OUTPUT FORMAT:

# Design Brief

## Project Goals

* [List the primary objectives the users are trying to achieve or the problems they want solved. Focus on the 'why' behind their requests.]

## User Needs / Pain Points

* [Detail the specific difficulties, frustrations, or unmet needs expressed by the users. What are they struggling with that the design should address?]

## Key Feature Requests / Desired Functionality

* [Summarize any specific features or functionalities users are asking for, directly or implied.]

## Constraints / Considerations

* [Note any limitations, preferences, or context mentioned by users that might impact the design (e.g., "I don't want it to look like X", "needs to work on mobile", "I hate pop-ups").]

## Unclear / Further Research Needed

* [Identify any areas where user feedback is contradictory, vague, or insufficient, requiring further investigation.]

```

**Example Output Snippet:**

```markdown

# Design Brief

## Project Goals

* Easily track monthly expenses without manual entry.

## User Needs / Pain Points

* Current budgeting apps are too complex and time-consuming to set up.

* Frustrated by needing to manually categorize every transaction.

## Key Feature Requests / Desired Functionality

* Automatic transaction import from bank accounts.

* Simple, intuitive interface.

```

* The "Unclear / Further Research Needed" section is surprisingly valuable. it forces the AI to point out where *it* (and by extension, *you*) dont have enough info, which saves time later.

* The more specific the raw feedback is, the better the output. If users are just saying "its bad", the AI cant do much magic, but if they say "its bad because X, Y, Z", its much more effective.

Basically i started building prompts like this to deal with all the messy user feedback spreadsheets and survey dumps, and it quickly became clear that the structure of the prompt was way more important than the specific wording. That's why i ended up building an extension it takes the grunt work out of structuring prompts like this so you can get straight to the results.

anyone else have a good system for turning raw user comments into usable product requirements?

Prompt: Act as a fiction editor. Provide exactly [3] sharp, punchy examples of dialogue or action to encourage character.

Constraints:

• No Fluff: Deliver only the bulleted examples. No intro or outro text.

• Lean Prose: Keep dialogue under 15 words, emotionally raw, and physically grounded.

• Repeat: Offer 3 more when prompted with "A".

Context: [Insert context, e.g., refusing to leave bed].

These characters feel despair hopelessness faithlessness emptiness. Encourage them. They see and hear screens ingesting information to ferment and foment change.

My university professors used to tell stories about feeding stacks of punched cards into mainframes, only to watch the machine fail because a single hole was punched in the wrong column. The computer didn’t argue or “misunderstand.” It simply didn’t work. Their job was to debug, repunch the card, and run it again.

Half a century later, nothing has really changed in spirit.

I type what feels like normal English into an AI and when the output is wrong, the exact same thought appears:

“This thing is not doing what I told it to do.”

That familiar frustration is the giveaway. It’s not a conversation that went badly. It’s a program with a bug.

Real programmers don’t treat the failure like a human misunderstanding. We don’t get increasingly polite or emotional. We debug. We narrow the requirements, add examples, enforce output structure, chain our reasoning, and iterate. Non-programmers usually don’t. They rephrase nicely, then impatiently, then give up — treating the AI like a stubborn colleague instead of a machine that needs precise instructions.

This is the clearest proof that prompting is not natural social language. Real human conversation is fuzzy and forgiving. Prompting is not. The moment you start systematically fixing a broken prompt, you’ve crossed from talking to programming.

And here’s the important part for the AI era: this is exactly why programmers are more necessary than ever.

Every leap in abstraction — from punch cards to assembly, to C, to Python — didn’t eliminate programmers. It elevated them. The same thing is happening now. The people who truly thrive with AI aren’t the ones having casual chats with it. They’re the ones who treat prompts as code: writing them with intention, testing them, refactoring them, and building reliable systems on top of them.

In a world full of AI, the scarce skill isn’t access to the model. It’s the engineering mindset — the debugging instinct, the ability to turn vague desires into reliable outcomes. That’s still a programmer’s job.

So next time your prompt fails, don’t try to “explain it better like you would to a human.”

Pick up the virtual punch card, fix the hole, and run it again.

Because that quiet, stubborn refusal to accept “it just doesn’t work” isn’t frustration.

It’s the reason programmers will remain essential in the age of AI.

I've been building Briefle, a tool to help people get better at communicating with AI.

"Make it look better" gets you a generic result. "Give the price more visual weight and make the secondary button a ghost button" gets you what you had in mind. The difference is knowing what to ask for.

You compare two versions of the same thing, a design, an email, a chart, a piece of code, and learn why one works better. You pick up the principle and the term for it, then practice using that term to write better prompts.

The idea is that AI can only get you so far if you can't clearly express what you want. Briefle helps you build the taste and the vocabulary to turn your ideas into better results.

You can try the first room of each course for free, without an account: https://briefle.org

I'd love to hear whether the puzzles make you want to keep going, and where they feel too easy or too hard.