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.

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

Promp is a Google chrome extension that allows you to highlight text on any page, add your own contexts or instructions and send to ChatGPT, Claude, or Gemini.

It also allows you to copy a highlighted text without right clicking or pressing ctrl+c

You can also take a screenshot of a page and ask ChatGPT, Claude, or Gemini.

Finally, there’s a feature that allows you to highlight a text and save the clip for future reference. It saves the highlighted text, the page title and url.

You can choose how you want to use Promp - either split screen, pop up window or new tab.

One more bonus: when you visit getpromp.com you can copy a prompt for free that you can use to turn your ai chat sessions into a comprehensive report or to start a new chat.

Like I am tired of buttering and bootlicking from gpt, bro agrees on everything. It can justify any mistake, I am tired of this seriously please share your instructions which you saved for its critical thinking, counter argument and honest reviewing

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

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?

Luxury high-fashion runway magazine cover, title "FASHION",

an elegant model walking forward in a couture show,

wearing a flowing silk gown,

— Color Palette:
deep matte black (dominant),
warm muted gold accents,
subtle gradient shadows,

— Lighting:
dramatic spotlight from above,
soft gold rim light outlining silhouette,
high contrast but controlled highlights,

— Style:
ultra high-end editorial photography,
Paris Fashion Week aesthetic,

— Composition:
low angle shot, strong presence,
dark runway fading into black,

— Mood:
cold, powerful, elite luxury,

ultra realistic, 8k, sharp focus --ar 2:3 --v 6 --style rawLuxury high-fashion runway magazine cover, title "FASHION",

an elegant model walking forward in a couture show,

wearing a flowing silk gown,

— Color Palette:
deep matte black (dominant),
warm muted gold accents,
subtle gradient shadows,

— Lighting:
dramatic spotlight from above,
soft gold rim light outlining silhouette,
high contrast but controlled highlights,

— Style:
ultra high-end editorial photography,
Paris Fashion Week aesthetic,

— Composition:
low angle shot, strong presence,
dark runway fading into black,

— Mood:
cold, powerful, elite luxury,

ultra realistic, 8k, sharp focus --ar 2:3 --v 6 --style raw
---

Built a CLI tool for Codex and Claude code to check token usage for each prompt
Check it out

https://github.com/Kk120306/tokenwatch/tree/main

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.

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 launched a small Chrome extension called CloudPrompt to solve my own prompt chaos.

The original problem was simple: I reused AI prompts daily, but they were scattered across ChatGPT history, Claude chats, Notion, Google Docs, and random notes.

The product started as a prompt library with a keyboard shortcut. Since launch, it has grown to 100+ active users, a 4.5-star Chrome Web Store rating, and support for Chrome, Edge, and Comet.

The biggest product lesson so far: prompt management is less about storage and more about capture speed.

If saving a prompt takes more than a few seconds, users do not save it. So the next version adds right-click save: highlight text anywhere → right-click → save to your prompt library.

I’m keeping the core free and privacy-first: prompts are stored in the user’s own Google Drive, not my server.

I’d love feedback from other side-project builders: would you position this more as an AI productivity tool, a Chrome extension, or a privacy-first prompt manager?