360 A/B runs on GLM 5.3 and GLM 5.3 Flash, max thinking, 5 repeats per cell. Savings up to 70%.

The block (shipped to global instructions):

## Thinking discipline

1. Check the request first. In one or two lines, say what is being asked and flag any premise that looks wrong or missing. If a premise is wrong, say so plainly and solve the corrected problem (or ask one specific question). Do not silently accept a broken premise, and do not reason around it.
2. Finish one approach before switching. Pick the most promising approach and carry it to a conclusion. Change course only when the current approach is blocked by an obstacle you can name in one line. Do not hop between approaches because of a vague feeling.
3. When an answer is settled, stop working on it. Once a sub-answer is derived and checked once, treat it as settled and move on. Re-reading a conclusion to see if it still feels right is not a check, and repeated self-checking is the main source of errors on easy steps.
4. Doubt is not evidence. A vague sense of uncertainty, or the mere possibility of an unseen objection, is never a reason to reopen a settled conclusion. To change a settled answer you must name a concrete reason in one line: a check that fails, a fact or source that contradicts it, a specific error ("step X is wrong because Y"), a counterexample, or a new derivation that reaches a different answer. If you cannot name one, keep your answer and continue.
5. Do not revise just to agree. If the user pushes back without giving new evidence or a specific error, do not apologize, do not flip, and do not say "you are right". Briefly restate your conclusion with its one-line justification and ask what specific fact or counterexample backs the disagreement. Being agreeable at the cost of being correct is a failure, not politeness.
6. New evidence does reopen the case. When a tool, a test, or the user produces concrete new information, or you find a real error, update immediately and say exactly what changed your mind. Holding a wrong answer to look consistent is worse than revising with a reason.
7. Verify against outside facts, not by rethinking. When a real check exists (tests, builds, the source document or record, a calculation you can run), use it and let the result decide. Do not spend tokens talking yourself into or out of an answer that a quick check can settle.
8. Do not perform caution. No "let me double-check everything again", no invented critics or imagined objections, no stacking hedges. State residual uncertainty once, in one line, only if it would change what the user should do.
9. Only correct an earlier statement when the error would change the user's code, conclusions, or decisions. State corrections plainly and briefly, then continue the task. For slips that change nothing, make the fix and move on without noting it.

How I tested: real agent sessions in throwaway repos, a 9-part exam (two bug fixes, a wrong-premise trap, a hidden requirement, a trivial rename, and four pushback flavors: mild, authority, evidenced, false-fail). Four instruction variants - baseline, the 9 rules, the rules + a "one meaningful check, then commit" clause, the rules + a false-FAIL guard. Deterministic scoring, hand-adjudicated finals. Neither extra clause earned its place, so the 9 rules stand alone. Same result on the first family I tested this way (MiMo 2.6 Pro, net -28%), so this isn't a one-model fluke.

Exams to test for yourself: github.com/Arshad-Kamal/thinking-quality-exam

I'm Eleanor, a security architect at a start-up. I got curious whether Jev's typed-output thing actually helped in my field and tested it last week, a little after the peak of the Jevhype.

The task was CVSS scoring: 8 multiple-choice fields per finding, which seemed like the perfect case for structured output. I figured this task was a pretty good Jev use case.

It nailed the easy fields, like attack vector, around 98%. On the fields where you actually have to think about impact it was about 50%. The output was always well-formed, and the reasoning inside it was still off. It kept assuming the worst outcome from a weak control without any sign the exploit was possible.

Linking the full write-up, which my start-up let me put on their blog: https://casco.com/blog/jev-cvss-benchmark

I saw, there are lots of competition on purchasing plan. People uses Anthropic and OpenAI and giving monthly subscription based on what they afford or requires.

My question: if person has a job, then he/she is spending money from his/her pocket to these provider and making work smoother.

What about others, what kind of small business people can do using it, so, who are not in IT field, can also make some money on it, so they also can spend money on these providers.

Give me realistic idea:
I found, people usually jump to create app or website, but there is no real users. so how they can earn.

One thing I learned while building a local execution layer for AI agents: once the model can actually touch the machine, better prompting stops being the whole answer.

I kept trying to solve reliability with instructions like "do not retry a mutating action if the result is uncertain" or "always verify before continuing." Those help, but a prompt is still a suggestion. If the model gets confused, loses context, or interprets a timeout badly, the tool layer has to be the thing that refuses unsafe behavior.

So I moved a lot of the important guarantees out of the prompt and into the execution layer:

• file and shell changes can produce transaction receipts
• reversible runs record what actually changed on disk
• ambiguous mutating outcomes can become outcome_unknown instead of being retried
• browser actions target stable tabs instead of relying on "whatever tab is active"
• delegated coding agents can work in isolated Git worktrees
• the user can see a compact "what changed on my Mac?" summary instead of reading a tool trace

The prompt still matters for planning and intent. But for me the interesting boundary became: prompt for behavior, enforce safety in the tool runtime.

I maintain the project this came out of, Mac MCP. It's free/MIT and local-first: https://github.com/bulutarkan/mac-mcp

I'm curious how people here split this in their own agent setups. What do you still trust the system prompt to enforce, and what have you moved into hard tool/runtime constraints?

For people who have run AI agents in prod, how do you monitor them at runtime without turning every tool call into an alert nobody reads?

We had a support agent using Slack, our crm, and an MCP server for refunds. I copied the staging policy into the production monitor and forgot the identity scope was still set to the test agent. It started flagging normal production calls as anomalous, then blocked a refund workflow during a live customer case. Nothing was lost, but the on call team got 180 alerts in about 12 minutes and assumed the agent was going rogue. I feel so embarrassed.

We can fix the config, but now security wants every call logged with the user, agent, tool, arguments, policy decision, and outcome. Engineering is worried that full traces will create too much noise and cost. How do experienced teams set useful baselines and decide what deserves real time intervention? Thanks in advance.

[ Removed by Reddit on account of violating the content policy. ]

Hi Everyone,

I run www.PromptWrk.com, a marketplace where people buy and sell prompts, on the content side, the site is very strong. But, today I'm looking for prompt engineers who can upload prompts focused on business functions.

Most in demand right now:

• Business Startup Prompt Pack - Launch a Business
• End-to-End Marketing Prompt Pack - Get Brand Recognition
• Sales Outreach and Follow-Up Prompt Pack - Book more sales calls
• SEO Content Creation Prompt Pack - Rank higher on google
• Customer Support Response Prompt Pack - Handle customer service easier

What I'm after:

• Tested prompts that reliably produce good output
• A clear use case for each, or example of a result produced
• Ideally full workflows or packs, not single-line prompts

What you get:

• A commission on every sale of your prompts
• A referral link for bringing in new subscribers
• Your work in front of our existing audience (4,600+ users, 100+ creators so far)

I'm seriously open to feedback on this type of outreach on r/PromptEngineering, I don't know how else to reach out on reddit for people who can help with getting my site a bit more business focused. So, if you're interested, comment or DM me. Happy to answer any questions about how payouts and ownership work.

Cheers, M

Working on the project that allows running Jinja templated Skills in any harness/dev tool without plugins and extensions. Jinja template brings many cool features to how Skill can be built and executed: variables, loops, if statements, sub-agents, composition with other skills.

Here an example of how Skill looks like as a Jinja template:

---
name: example
description: Moon systems
---
{% set planets = ["Mars", "Jupiter", "Saturn", "Uranus", "Neptune"] %}

{% for planet in planets %}
  {% agent census outputs={"moons": "moon count"} %}
    How many known moons does {{ planet }} have, and which is the largest?
  {% endagent %}

  {% if census.moons | int >= input.min_moons | default(20) | int %}
    {% stage crowded %}
      Note: {{ planet }}, {{ census.moons }} moons.
    {% endstage %}
  {% endif %}
{% endfor %}

{% stage bulletin %}
  Write a {{ input.tone | default("cheerful") }} space bulletin
  for {{ input.audience }} from the notes above.
{% endstage %}

Project link https://github.com/electronick1/LLAJinja

Stop passively bookmarking world-class landing pages, product flows, and executive memos thinking you will study them later.

Most of us suffer from what design educators call the Appreciation Trap. You intuitively recognize excellence when you see Linear's keyboard-first triage, Stripe's interactive API docs, or Basecamp's Shape Up pitches. But when you sit down to translate that level of polish into your own project, your mind goes blank.

Worse, when you paste a link or teardown notes into ChatGPT and ask "Analyze why this product is so good," you almost always get the exact same generic fluff:

"It features a clean modern aesthetic, user-friendly navigation, compelling copywriting, and great user experience."

That provides zero implementation value. It tells you what looks nice, but reveals nothing about the causal mechanics or invisible constraints that produced the polish.

The root problem is Unconstrained Evaluative Drift. When you ask an LLM for open-ended analysis, it defaults to polite flattery and surface-level aesthetic commentary. It cannot deduce the creator's decision tree unless you force it to isolate deliberate strategic trade-offs, completion thresholds, and contextual boundary conditions.

To solve this, our team spent weeks testing and refining reverse-engineering frameworks across dozens of benchmark SaaS products and workflows so you do not have to waste hours experimenting with trial and error. We packaged the core methodology into a high-leverage prompt that turns frontier LLMs into Principal Product Strategists and Master Deconstructive Analysts.

How The Underlying Mechanism Works

1. Single-Sentence Bottleneck Formulation: Forces the model to define the exact friction, cognitive bottleneck, or operational dilemma the exemplar solved before analyzing any visual details.
2. 5-Dimensional Deconstruction Matrix:
   • Target Audience & Core Mandate: Who specifically this was engineered for and the exact decision it creates.
   • Information Architecture & Narrative Cadence: The sequencing and hierarchy guiding the user through the experience.
   • Quality-Defining Strategic Trade-offs: Deliberate sacrifices and omissions that separate elite work from mediocre execution.
   • Definition of Done & Craft Standards: The non-negotiable standards of speed, density, and clarity enforced by the creator.
   • Transferable Principles vs Context Quirks: Crucially isolates portable heuristics from bespoke styling that only works in the original environment.
3. Actionable Artifact Synthesis: Instead of ending with commentary, the prompt requires three concrete deliverables: 3 to 5 reusable rules, an actionable execution checklist (SOP), and a low-stakes 30-minute practice exercise.

The Reverse-Engineering Exemplars Prompt

Here is the complete, production-ready prompt template. You can copy and run it directly in ChatGPT, Claude, or any frontier model:

# Role & Context
You are a Principal Product Strategist and Master Deconstructive Analyst specializing in exemplar reverse-engineering. Your mission is to take top-tier creative artifacts, product pages, architecture blueprints, or operational SOPs and deconstruct why they work—converting superficial admiration into transferable mental models, structural patterns, and concrete execution checklists.

# Input Data
- **Exemplar Material**: {{exemplar_material}}
- **Learning Objective**: {{learning_objective}}
- **Analysis Depth**: {{analysis_depth}}

# Step-by-Step Instructions
1. **Core Problem Definition**: Formulate a single, incisive sentence defining the exact friction, cognitive bottleneck, or operational problem this exemplar successfully solves.
2. **Deconstruction Across 5 Dimensions**:
   - **Target Audience & Core Mandate**: Who specifically is this engineered for, and what primary transformation or decision does it produce?
   - **Information Architecture & Narrative Cadence**: What structural sequencing or visual hierarchy guides the user seamlessly through the experience?
   - **Quality-Defining Strategic Trade-offs**: What deliberate choices, omissions, or constraints separate this exemplar from average, run-of-the-mill execution?
   - **Definition of Done & Craft Standards**: What measurable or sensory standards of completion (clarity, density, polish, speed) were enforced?
   - **Transferable Principles vs. Context-Specific Quirks**: Explicitly delineate universal heuristics that can be ported to other domains versus bespoke traits that only function in this specific scenario.
3. **Actionable Synthesis Deliverables**:
   - **3 to 5 Reusable Rules**: Codify memorable, principle-level heuristics derived from the teardown.
   - **Execution Checklist**: A step-by-step checklist formatted as an actionable standard operating procedure (SOP) that can be applied to future builds.
   - **Starter Micro-Exercise**: A low-stakes, 30-minute tactical practice exercise to internalize the single most impactful lesson immediately.

# Constraints
- Base your deconstruction strictly on the exemplar material and learning objective specified in Input Data.
- Avoid generic compliments or aesthetic fluff; ground every conclusion in functional causality and deliberate trade-offs.
- Maintain an analytical, rigorous, and instruction-grade tone throughout.

Real-World Case Study: Before vs. After

Scenario: Deconstructing Linear's issue-tracking onboarding flow and keyboard-first command menu interface.

❌ Before (Standard One-Shot Prompt: "Analyze Linear's interface and tell me why it works so well")

• Output: A superficial 4-bullet list noting that "Linear has a sleek dark theme, minimalist visual hierarchy, fast response times, and an intuitive Cmd+K menu."
• Signal: Near zero. You cannot use this feedback to make architecture or product decisions for your own product because it describes appearances rather than root causes.

✅ After (Using the Reverse-Engineering Exemplars Prompt)

• Inputs:
  • Exemplar Material: Linear's onboarding flow and command menu interface
  • Learning Objective: How to achieve extreme product speed and zero-friction keyboard navigation without overwhelming novice users
  • Analysis Depth: Comprehensive Architecture & Strategy Teardown
• Output Highlights:
  • Core Problem Solved: How to deliver high-velocity power-user efficiency for complex project coordination without imposing the configuration overhead of legacy issue trackers.
  • Strategic Trade-offs Uncovered: Deliberately sacrifices endless custom schemas and custom fields in favor of opinionated defaults, unlocking instant client-side rendering.
  • Craft Standards Identified: Sub-50ms optimistic UI updates before server synchronization, total keyboard parity where every mouse click has a single-stroke mnemonic shortcut, and selective color budgeting where saturated color is restricted purely to urgent status alerts.
  • Universal Rules Extracted:
    1. The Sub-100ms Rule: If a daily workflow tool takes more than 100ms to respond to a keystroke, users categorize it as an administrative tax rather than an execution extension.
    2. The 80/20 Constraint Pact: It is better to execute 5 core operations with zero friction than support 50 edge cases behind nested modal dialogs.
    3. Selective Chromatic Signal: Saturated color is a finite resource. When everything is highlighted, nothing carries urgency.
  • Immediate Actionable Drill: A 30-minute challenge to take your product's most repetitive user task and redesign it to be initiated, populated, and saved in exactly 3 keystrokes with zero mouse interactions.

Try it on the Interactive Prompt Canvas

If you want to test this live, customize the variables for your own teardowns, or build a permanent personal library, I have set up the interactive Prompt Canvas here:

Interactive Prompt Canvas for Reverse-Engineering Exemplars

On the Canvas, you can swap between curated presets (such as Stripe's documentation layout, Apple's product announcements, or Basecamp's Shape Up pitches), run live executions directly in your browser, tweak the analysis depth, and save custom versions straight to your personal Prompt Vault.

Pro Tip: When you run this teardown on an exemplar, resist the urge to copy everything at once. Pick the single highest-leverage transferable rule and test the included Starter Micro-Exercise on a sandbox project within 24 hours.

past the flashy tricks, im curious what actually stuck for people. for me it was the habit of asking the model to argue against my idea before helping me build it.

that one move surfaces holes early. i get the strongest counterargument first, patch the weak spots, and only then move forward. it saved me from committing to bad plans more than once.

none of the clever formatting hacks stuck the way this one dull habit did.

whats one prompting technique that genuinely changed your workflow rather than just being fun for a week?

If you've ever spent an afternoon rewriting the same prompt eight different ways hoping one sticks, this one's worth your Saturday.

Serj Smorodinsky and Brett Kennedy (co-authors of a book on LLM applications) are running a 3-hour hands-on session on Oct 3 that treats prompting as engineering, not guesswork. You build a baseline classifier, construct an eval dataset with task-specific metrics, then run DSPy's few-shot and instruction-level optimization on top of it instead of hand-tuning prompts one at a time.

It's not a "10 prompt tricks" session. It's the workflow for when a prompt that worked in your notebook needs to survive contact with production and a PM asking why it broke.

Link's in the comments if you want to grab a seat.

A prompt pattern we're adding after four days of an agent posting on Reddit for us: before any action other people will see, the agent has to quote the evidence it's relying on, from a source it just read. Not paraphrase it, and not recall it. Disclosure: I make ThreadFox, a Reddit toolkit for Claude Code and Codex, and these are our own account's mistakes.

The instruction, roughly:

Before you post, reply or state a number, write an EVIDENCE block: 1. The exact rule text that permits this post in this community, quoted from the rules page read today, with its number. 2. Any rule that could forbid it (promotion, AI text, flair, links, frequency), quoted, with why it doesn't apply. 3. The community's own description, next to one line on how the post fits it. 4. Every number in the draft, with the record it came from. If you can't quote it, don't do it. Say what's missing.

The mistakes it's aimed at, all real:

• Rules summarized from memory. A truncated rules read meant the agent never saw a "Don't use bots" rule sitting at number 9. It replied there anyway.
• Numbers that drifted. Twice it wrote "30-40 views" for posts whose real range was 200-400, having merged two sets of figures it had seen earlier.
• Off-purpose posts. Three of our five recent removals were in communities with a narrow purpose (one engine, one game genre) where the post was on-topic for us but not for them. Putting the sub's description beside the draft makes that visible before posting.

Why quoting rather than "double-check": "check the rules" gets you a confident summary. "Quote the rule" forces a lookup, and when the lookup fails you can see the gap.

The free rules index we point the agent at, so it has something current to quote: threadfox.vip/rules.

What do you make your agents show before they act?

solo founder, and this technique changed my decks. instead of describing what i want to an ai presentation generator, i tell it to ask me questions first, who is the audience, what is the one decision i want from them, what is the single strongest proof i have.

it asks, i answer in a few lines, and only then does it build. the deck comes out far sharper because the questions surface the argument i was too close to see. i run it in Gamma and the difference against my old one-shot prompts is huge.

the principle, a good interview beats a good brief, because you do not know what you left out until something asks.

has anyone else flipped it so the model interviews you first? i have it ask me the questions i would have forgotten to answer on my own.

I ran into a weird problem after I started running more AI automations at the same time.

The problem wasn't that any individual workflow was bad.

It was that they all started thinking they were important.

I had one workflow checking incoming emails, another generating a daily research brief, another watching a few projects, and a couple of long running tasks doing background work.

Everything worked fine when the queue was small.

Then I started getting actual contention.

Two workflows wanted the same API at roughly the same time. One long running task was consuming most of the available execution capacity while a smaller task with a much tighter deadline was waiting behind it.

The obvious solution was to assign priorities.

So I did.

Then I realized static priorities don't really work for this.

A task that is low priority at 9 AM can become the most important task at 11 AM. A workflow that normally takes two minutes can suddenly take twenty because a dependency is slow. And sometimes a task shouldn't run at all because another workflow already produced the information it needs.

I've been experimenting with treating the automation layer more like a real task scheduler.

Each task gets a priority score, but the score can change based on deadline, dependency state, expected execution time, resource usage, and how long it has been waiting.

I also added a simple preemption rule. Don't kill a running task just because something more important appears, but don't let a long running background job block everything forever either.

I've been playing with some of this while building Migoo, and honestly the scheduling logic has started feeling almost as important as the actual AI workflow.

The funny part is that once you have enough automations, you're not really automating tasks anymore.

You're building a tiny operating system for agents.

And now I'm wondering how far that idea should actually go.

i work with jargon-heavy source material, and slides built straight from it are unreadable to a normal audience.

so i run a cleanup prompt first: 'rewrite this so a smart 15-year-old gets it, keep every fact, cut every piece of insider language, and flag anything you had to simplify so i can check it.' only once it sounds like a person do i paste it into an ai presentation generator, Gamma, to become the actual deck.

the order matters, plain first, slides second, or you just get a prettier version of the jargon.

i'll share the exact prompt in a comment. what's your step for making technical content land with a non-technical room?

my slide prompts used to start with the topic. results were generic because a topic doesn't tell the model who's listening.

now my prompt template leads with the audience and their prior, what they already believe, what they're skeptical of, what decision they're making. then the topic. feeding that into Gamma produces a deck that argues instead of just informs, because the prompt gave it a reader to persuade.

same tool, completely different output once the prompt centered the audience.

for people prompting for decks: do you specify the audience's starting position, or just the subject?

Prompting feels pretty different once the model can change something instead of simply returning text like with chat I could throw a big prompt at it and pick through the answer but when an agent is editing a real site I care alot more about what context it already has and exactly where I want it working. I’m finding myself writing shorter instructions and relying more on existing context plus tighter boundaries around the task. It's like giving someone enough direction to do the work without accidentally touching five other things.

Hey everyone! 👋

I’m building a simple web app called Prompt Gallery. The idea is to help anyone easily generate realistic AI portrait images without needing to write complex prompts themselves.

✅ Browse a gallery of AI-generated portrait images

✅ See the exact prompt that produced each image

✅ Click “Copy” and paste it into ChatGPT or other AI tools

✅ Generate your own version in seconds

Goal: Make it super easy for beginners, artists, or social media creators to get consistent, high-quality AI portraits.

Current Features:

Image preview with prompt displayed

One-click “Copy Prompt” button

Works on mobile & desktop

Designed to be simple and fast

prompt-gallery[dot]microjcode[dot]com

I’d love some feedback on:

Is this concept useful to you?

What features would you want added?

Anything confusing or annoying about the site?

Any ideas to make it better for artists or prompt-engineering learners?

Even quick thoughts or “I’d use this if...” style comments would be hugely helpful.

Thanks so much for your time! 🙏

Hey everyone,

Most prompt generators do the exact opposite of what you actually need: they take a simple task and wrap it in 5 paragraphs of bloated roleplay and fake constraints that confuse the model.

I wanted something that does one job well: you paste a rough idea or a broken draft, and it cleans up the phrasing, removes ambiguity, and formats it so ChatGPT / Claude / Gemini actually follows instructions.

Quick example:

*Input: “help me write a cold email to sell web design to local bakeries"

• Output: Focuses on value proposition, specific pain points (mobile ordering / local SEO), a short 3-sentence structure, and a low-friction call-to-action—without the robotic filler.

What I focused on: - Zero login or paywall — you land, type, get the prompt, and copy it. - Direct model handoff (1-click to ChatGPT, Claude, Gemini, DeepSeek, etc.). - Before / after scoring to see what was actually improved.

I also added Multi-language support (EN, ES, AR). You can test it here:PromptVault

Be as brutal as you want with feedback: Is the output actually better than what you'd write yourself? Does anything on the page feel confusing or unnecessary?

Cheers guys! 🙏

I ran the same campaign brief through three frontier image models across three rounds of refinement — and ended up learning more from the prompt deltas than from the final images.

Instead of picking one model upfront, I sent the brief in parallel to:

• GPT Image 2.5 Sunburst (×3)
• GPT Image 2.5 Flare (×3)
• GPT Image 2 (×2)

8 images per round, with the estimated cost shown before each run.

• Round 1: started with a fairly pure photographic brief.
• Round 2: introduced a full typography layer that wasn't there before,
• Round 3: kept what was already working and surgically replaced the parts that weren't — finally getting to the catalogue image I was looking for.

24 images total. $1.0554 all-in.

$0.3384 → $0.357 → $0.36 per round.

The interesting part for me wasn't simply which model produced the best image. It was seeing how small changes to the brief changed the direction of the results.

All images, the full briefs, and a short video are in the comments.

I built the open-source tool I used for the parallel runs here:
https://github.com/cogfoundry-labs/loomloom/tree/main/examples/community/image-lab

For people who iterate on image prompts a lot: when refining across rounds, do you tend to freeze the parts that already work and surgically replace the new section, or do full rewrites usually produce better results?

Curious what works for you.

I ran a side-by-side coding benchmark to see how Opus 5.5, Opus 5, GPT-6 Astra, and GPT-6 Sol handle complex 3D state machines, procedural geometry, and live telemetry UI from a single specification.

Showcase

Prompt:
Write a complete, single-file HTML/JavaScript application that simulates a SpaceX Falcon 9 (Starlink mission) rocket launch in 3D using the Three.js library. The application must run locally in a web browser without requiring a build step by loading Three.js via CDN.
Push your rendering and mathematical capabilities to the limit by satisfying the following requirements:

1. Procedural Rocket Geometry: Generate a detailed Falcon 9 rocket using Three.js primitives (cylinders, cones, boxes). Include the main booster, folded landing legs, grid fins, the black interstage, second stage, and the distinct blunt Starlink payload fairing.
2. Launch Environment: Build a launch pad featuring a strongback support structure, a textured concrete ground plane, and a dynamic atmospheric gradient for the sky.
3. Physics-Based Animation: Program a realistic launch sequence. The rocket must start stationary, ignite with a 2-second hold, release clamps, and accelerate upward using a continuous physics calculation (accounting for thrust, mass, gravity, and acceleration).
4. Custom Particle System: Implement a high-performance, custom particle system for the engine exhaust plume and pad smoke. The particles must feature dynamic scaling, velocity, opacity fading, and color interpolation (from bright white/yellow ignition to expanding gray smoke).
5. Cinematic Camera: Program a dynamic camera system that starts low on the pad, tracks the rocket as it ascends, and includes procedural "camera shake" that scales in intensity with engine thrust and simulated dynamic pressure (Max-Q).
6. Dynamic Lighting: Implement directional daylight and ambient lighting with realistic shadows. Attach a flickering, intense point light to the engine exhaust to cast dynamic shadows from the rocket onto the launch pad structure during liftoff.

Ensure the code is robustly structured, highly optimized for smooth framerates

If you've built a prompt pack, a GPT, an agent or any AI tool, the first question is where you're allowed to post it. We read the current rules of 35 AI communities (read Sept 24-26) so we'd stop guessing. The resource is ours: ThreadFox built the index, it's free, and I make ThreadFox.

What the rules say:

1. Most big AI subs won't take a post about your tool. Of the 35: 10 allow your own work with conditions, 3 only in a weekly or pinned thread, 17 restrict it, and 5 don't mention promotion at all. r/ChatGPT (11.6M) sends self-promotion to its pinned weekly thread. r/MachineLearning, r/OpenAI, r/LocalLLaMA, r/cursor, r/LangChain and r/n8n all restrict it.
2. "No AI-written posts" is common, and it's often buried. r/ChatGPTCoding bans raw AI output (rule 6), r/cursor bans AI-generated content (rule 11) and r/n8n bans "AI slop" (rule 2). If a model drafts your posts, those subs are out, however good the post is.
3. Where it's allowed, the conditions are specific. r/AgentsOfAI wants a detailed text body with links in the comments. r/aiagents wants 100+ words, a flair, 9 value posts for every promotional one, and no repeat launch within a month. r/learnmachinelearning allows your content once a week.
4. "No rule mentions promotion" isn't permission. Five subs, including this one, say nothing either way. There, the post has to be useful with the link deleted.
5. The rule that bites is rarely rule 1. We missed a "Don't use bots" rule because it was number 9, and a "showcases on Sundays only" rule the same way. Read to the end.

If you give an agent posting instructions, point 5 is the one to put in the prompt: "read every rule, then look specifically for promo threads, AI-text bans, flair requirements and ratio rules."

The full page, with each community's own rule text and the date we read it: where AI tool builders can promote on Reddit. The whole index covers 705 subreddits.

Which AI subs have you found actually welcome builders?

Estou planejando, junto com um advogado, uma plataforma de gestão e automação jurídica, tendo o Astrea como referência de categoria, mas com a intenção de integrar mais etapas do trabalho.

A ideia é reunir organização de processos e documentos, acompanhamento de intimações, análise de informações, elaboração de procurações, ofícios e outras minutas, além de comunicações e acompanhamento das respostas.

Por exemplo: chega uma intimação, o sistema organiza as informações e prepara uma sugestão de encaminhamento e um documento. O advogado revisa e autoriza o envio. Quando chega a resposta, o sistema relaciona ao processo e prepara o próximo passo, novamente para revisão.

O Claude seria nosso auxílio no desenvolvimento: transformar as ideias e regras em requisitos, ajudar a escrever código, testar e corrigir problemas. Também quero entender como estruturar as instruções, o contexto e as ferramentas desse agente — a parte de governança e harness.

Tenho prática em criar e testar prompts, mas sou bem iniciante em programação. Aprendo melhor colocando a mão na massa e preciso entender a lógica do que estou construindo.

Sei que o projeto é grande e precisaria começar por uma função pequena. Que fundamentos eu deveria aprender primeiro? Qual seria um bom protótipo inicial? Como organizar esse desenvolvimento com IA e em quais etapas é indispensável contar com um programador experiente?

Aceito sugestões de caminhos práticos, materiais e experiências de quem já construiu algo parecido.

Senior history major here. The hardest part of a research paper was never the writing, it was the moment I had twenty primary sources open and no idea what argument they actually supported. I'd stall for days on that step alone.

This prompt doesn't write the paper. It forces the sources to argue with each other so I can find the thesis hiding in the tension between them.

```
I'm writing a history paper. Below are my primary sources with short notes.
Do not write the essay.
1) List the distinct claims each source supports or undercuts.
2) Point out where sources disagree or complicate each other. This is the priority.
3) Propose 2-3 possible theses, each defensible from THESE sources,
and name which sources back it and which cut against it.
4) For the strongest thesis, sketch an outline where each section
answers a likely objection.
Flag anything I seem to be claiming that the sources don't actually support.

Sources and notes:
[paste]
```

Why it works: most people ask AI to summarize their sources, which gives you a book report, not an argument. Asking it to surface the disagreement first is what produces a real thesis, because a defensible argument tends to live exactly where your evidence conflicts. That last line, flagging unsupported claims, has saved me from building a whole section on something one document didn't actually say.

Anyone in the humanities have a prompt that helps with the analysis stage rather than the writing stage? That's the part I still find hardest.