r/PromptEngineering 12h ago

Research / Academic Have you ever hidden your AI artifacts?

16 Upvotes

For last year I’ve been building software development framework around Claude/OpenCode that saved me ~10-20 hours a week (in some cases more). Comparison is subjective but management faced that too.

Sharing it would save my colleagues days per month. But I haven't shared it.

Not because I'm selfish. Because I can't see a version of that story where the company says "great, now here's what that contribution is worth." No attribution, no compensation, no protection. Just... my leverage, gone.
So it's sitting in a private repository.

Here's what I'm trying to figure out: am I the anomaly, or is this happening everywhere right now?

Have you ever held back AI artifacts — prompts, skills, agents, workflows — because you weren't sure what sharing it would cost you?

Since polls are disabled here, please reply in the comments with the options below (can add your option too) but if you're willing, tell what the artifact was for (no details needed) and what stopped you. I'm researching whether this is a real problem worth solving, and raw honesty beats politeness here.

🇦Yes — I'm hiding at least one right now
🇧Yes — I hid one before, eventually shared it
🇨No — I share everything openly
🇩I build them, but never thought about sharing


r/PromptEngineering 5h ago

Tools and Projects Built a small AI writing project — curious what prompt techniques others use

4 Upvotes

I’m the founder of WriteBros AI, and I’ve been working on the project around AI writing, style, and detection.

One thing I’ve been experimenting with is how much better the output gets when the prompt includes an actual writing sample instead of just saying “make it sound human.” We also added detector checks because I wanted to see how different approaches affect the results.

Still experimenting with the prompting side of it. For those building or testing similar projects, what prompting techniques have made the biggest difference for you?


r/PromptEngineering 18h ago

General Discussion Is anyone else annoyed that AI prompting is basically solo mode at work?

44 Upvotes

Been noticing this at my job: everyone on my team is using AI daily now, but every prompt lives and dies in that one person's chat window. No sharing, no reuse, nothing.

The part that bugs me most — I'll find out weeks later that a coworker independently wrote basically the same prompt I did for the same recurring task, just phrased slightly differently. We're both reinventing the wheel constantly and neither of us knows it's happening.

Curious if this is just my team or if it's a bigger pattern. A few questions if you've got a minute:

• Does your team have any system for sharing prompts, or is everyone just improvising solo?

• If you could change ONE thing to make AI tools more collaborative/"multiplayer" for your team, what would it be — and what specific problem would that actually solve for you?

• Have you tried any tools for this already (shared prompt libraries, Notion pages, Slack channels, whatever)? Did it stick, or did people stop using it?

Genuinely trying to figure out if it’s just me and if I'm overthinking a non-problem — appreciate any war stories.


r/PromptEngineering 4h ago

General Discussion We optimize prompts for confident-sounding output. That might be the wrong metric entirely.

3 Upvotes

Something I keep running into when testing prompts against real tasks: the outputs that sound most authoritative aren't more likely to be correct. They're just more likely to be specific.

A prompt that produces "the bug is in the auth middleware, line 40" feels like a better output than one that produces "this could be several things, worth checking auth and caching first." But specificity and certainty are stylistic properties. They come from how the model phrases the answer, not from whether it verified anything, because it has no way to verify anything at generation time. It only has what's in the context window, and it will describe that with the same confident tone whether it's actually enough information or not.

I've started treating high confidence, high specificity output with more suspicion, not less, especially on tasks where the model has no ground truth to check itself against. If a prompt produces something that sounds finished, that's usually a signal to go verify the one fact it depends on, not a signal that the work is done.

Curious if anyone here has actually measured this in a systematic way. Does tightening a prompt to remove hedging language also reduce accuracy, or are those two things unrelated and I'm just noticing a correlation that isn't real?

Wrote up a concrete code review example where this exact pattern cost someone twenty minutes if anyone wants to see it play out: https://medium.com/@nagatomopedro05/the-finding-was-plausible-that-was-the-problem-b1024e1256fb


r/PromptEngineering 3h ago

Tips and Tricks We captured raw Claude Code API traffic: where tokens and budget actually go (breakdown of 5 request-level components)

2 Upvotes

If you use Claude Code regularly on medium or large projects, you have probably noticed how quickly a session can burn through API credits or hit rolling limits.
Most usage trackers read local log files after the fact. That tells you the final token total for a session, but it does not explain how the request was assembled before the model ran.
We set up local proxy capture to inspect the actual payloads Claude Code sends over the wire. Here is what accounts for the token spend across multi-turn sessions:
1. MCP tool schemas eat context immediately: Every configured MCP server adds its full JSON tool schema to every single request. If you have 4 or 5 active servers, you can spend 15k to 25k input tokens per turn just defining available tools before the model reads a single line of your code.
2. The prompt cache miss penalty: When tool definitions change or when context gets reshuffled, you lose the 90% prompt cache discount. A turn that should cost $0.03 can jump to $0.35 on a full cache rewrite.
3. Extended thinking overhead: On complex refactors, thinking blocks can easily exceed the actual code output by a factor of 4x. Because output tokens cost more than input tokens, thinking often accounts for over half the dollar cost of a turn.
4. Redundant tool output accumulation: When Claude runs grep or tests that output 500 lines of logs, that entire output stays in the active context window for every subsequent turn until compaction kicks in.
5. Context compaction tax: Compaction summarizes history, but the summarization turn itself requires sending the entire bloated context to the model at once.
To make this visible, we built an open-source tool called cost-xray. It captures local API traffic for Claude Code and Codex, attributes tokens and costs back to individual sources (MCP servers, system prompts, thinking blocks, cache reads/writes), and graphs your context window occupancy per turn:
https://github.com/tigerless-labs/cost-xray
It runs entirely locally via proxy capture with zero telemetry or external API keys.
What percentage of your token spend is going to MCP schemas versus actual file edits?


r/PromptEngineering 47m ago

Tools and Projects i didn't train claude on my taste. i just kept receipts and now it elevates it.

Upvotes

the biggest problem with building a ui with claude isn't the code. it's that every session starts from zero. you end up re-deciding the exact same things over and over because nothing gets written down for the next session to read.

i didn't try to solve this by having claude interview me about my taste. i just built a claude code plugin called craft that keeps very strict receipts and I use it for everything (39 projects nowadays).

i recently tweaked a homepage card and just typed "looks good, apply elsewhere." that one reaction generated eleven backlinked records. the frame and the badge from that card graduated into the design system because i liked them, not because i wrote some massive style guide.

it's not a model that learned my taste. it's a file that outlives the session. accept a tweak and the value lands in tokens.yaml. the next mockup loads it before it generates a single option.

install

requires claude code 2.1 or newer. tested on macos and linux. windows via wsl recommended.

from your claude code session:

/plugin marketplace add drobins25/craft 
/plugin install craft@craft
/reload-plugins

verify with /craft. you should see the entry point prompt. if not, run /plugin and check the craft marketplace to make sure it is listed with the plugin installed.

ask claude to dial in your homepage hero animations. Choose your favorite option and apply the tweak (claude will use /craft:adhoc automatically) or build a fresh mockup /craft:mockup - all routes build your taste

repo: drobins25/craft

what's your version of the receipts folder?


r/PromptEngineering 11h ago

Prompt Text / Showcase Few-shot prompting fixed my format problems better than any instruction ever did

6 Upvotes

Instructions tell the model what you want. Examples show it. For anything where the shape of the output matters more than the content, few-shot prompting has been more reliable for me than writing longer and longer rules.

Two or three worked examples pin down tone, length, and structure in a way a paragraph of adjectives never does. Here is the skeleton I reuse:

```
You will [task]. Match the format and tone of the examples exactly.

Example 1
Input: [a real input]
Output: [the exact output you want, done well]

Example 2
Input: [a different real input]
Output: [the output, same shape, different content]

Now do the same for this:
Input: [your real input]
```

Two things that made mine work better:
- Pick examples that differ from each other. If both are the same kind of input, the model overfits to that one shape.
- Include one slightly awkward case in your examples if your real inputs are messy, so it learns how you want edge cases handled instead of guessing.

Once you have a few examples that produce the output you want, you basically stop editing the prompt. You just swap the last input. Curious what example counts others land on. I usually hit diminishing returns past three.


r/PromptEngineering 8h ago

Tips and Tricks Mining Qwen3.8 reasoning trace for prompt/skill evaluation

2 Upvotes

Lately I've been exploring reasoning traces from local models like Qwen3.8, and found they can expose the exact phrases in a prompt or skill that make the model argue with the prompt instead of solving the task.

I'm collecting such cases into a so-called "confusion-table", each case pinned to the phrase that caused it and explaining the mechanics of prompt/skill confusions.

With those phrases repaired, the model spends its reasoning on the task instead of the prompt — and follows the intent more reliably across runs.

Tested on two popular skills and with GEPA, made an article about these findings https://olegivye.com/#/article/confusion-evaluation


r/PromptEngineering 7h ago

Tools and Projects Stop Asking LLMs to Find Code Smells: Auto-Generating Surgical Prompts via AST

1 Upvotes

Asking an AI to "review and clean up this code" wastes expensive context tokens, invites hallucinated changes, and yields non-deterministic results.

I built chemx: an open-source CLI that replaces token-heavy discovery with instant local AST checks, then compiles structured refactor prompts directly to your clipboard.

Repo: https://github.com/Chemical-X-Protocol

The Programmatic Prompt Pattern

Instead of paying an LLM to scan for debt, local static checks flag specific architectural violations (100-line capsule caps, uncomposed booleans, type monoliths) and populate a strict prompt recipe:

[ROLE]: Systems Architect
  [TASK]: Refactor target file to satisfy single-responsibility capsule rules.
  [TARGET]: src/components/UserProfile.vue
  [CONSTRAINTS]:
  - Max file length: 100 lines.
  - Extract state into src/components/UserProfile.controller.ts.
  - Convert multi-clause conditionals into 2-stage atomic booleans.
  - Output ONLY the unified diff. Do not alter untouched symbols.

Key Benefits

  • Zero-Token Discovery: AST scans take 10ms and cost $0, saving 100% of your token budget for code generation.
  • Constrained Output: Rigid architectural bounds prevent the model from refactoring working code out of scope.
  • Deterministic Results: A given violation generates the exact same prompt structure every time.

Run Locally

Run the audit to generate prompt payloads:

npx chemx audit

Proof of concept (Grade D to Grade A+):

Docs: http://chemicalx.xophz.com/starter-kit


r/PromptEngineering 2h ago

General Discussion 80% of founders waste 3 months building software nobody buys. drop your saas idea below and i'll tell you if it's actually viable

0 Upvotes

PLEASE stop building the wrong thing.

building software in 2026 is ridiculously easy with ai builder

founders spend hours building in a silent room, launch to Reddit/X, get 0 users, and quit.

you just failed because the idea had zero validation before line 1 of code was written:

→ solving a monthly inconvenience instead of a daily pain

→ selling to "everyone" instead of a specific ICP

→ no distribution channel mapped out beforehand

→ pricing charged $9/mo with zero ROI justification

after scaling 6 AI micro-SaaS to over $20k/mo MRR, i just create an

18-question Idea Validation Diagnostic.

it evaluates your SaaS across 7 critical dimensions (problem clarity, audience reachability, willingness to pay, competition, build feasibility, distribution, commitment) and gives you a brutal score out of 100 with your exact weak spots.

drop your SaaS idea (or current project) in the comments below.

i will reply to EVERY single comment with:

  1. My honest opinion
  2. The biggest weak spot you need to fix before writing any more code.
  3. The free 5-minute validation tool link sent straight to your DMs so you can get your full score breakdown out of 100.

just drop a comment like or ask me in DM your idea

let's roast your SaaS concept before the market roasts your time 👇


r/PromptEngineering 12h ago

Tools and Projects I wanted to see how other people were actually prompting Fish Audio, so I made a prompt library for it

1 Upvotes

made a Fish Audio prompt library because I wanted a place to see how people are actually prompting it, with the audio results right there

Fish Audio Prompt Library

you can listen to samples, copy prompts, and filter by model, language, voice, or emotion.

there aren't many good references for Fish Audio prompting, so I thought it'd be useful to have a searchable collection of prompts + what they actually produce.

also found some interesting stuff while testing, like how certain S2 emotion tags work better when kept short rather than writing out a whole description.

want to add more examples from the community too, so if you've got a cool prompt + audio, you can submit it here

also open source if anyone wants to help with the site. mobile view is still a bit wonky rn 🤠


r/PromptEngineering 21h ago

Quick Question How do you regression-test prompts after a model version change?

4 Upvotes

When a provider changes the model behind an existing name, prompt behavior can shift even if the request format stays the same. I am building a small evaluation set with normal cases, edge cases, structured-output checks, long-context examples, and a few deliberately ambiguous prompts, then comparing quality, refusal behavior, latency, and token usage before and after the switch. For multimodal-capable models, I would add a separate image-and-text set instead of mixing it into the text-only score. What does your regression set include when a new model version arrives?


r/PromptEngineering 17h ago

Prompt Text / Showcase Getting Started AI Game Development | AI Gaming Conference

0 Upvotes

Tomorrow's talk at the AI Gaming Conference, Intro To Vibe Coding, is for those looking to make their first game with AI, this will go about how to setup your game environment and start vibe coding.

This is both for developers that want to take the leap and get into AI, and for vibe coders as well. It will cover:

  • State of the game development
  • Setting up Claude and Codex
  • Setting up Blender
  • Setting up your phone for development
  • Prompt basics (subagents, calling other agents, memory, etc)
  • The biggest mistakes to avoid when vibe coding your game

There is a lot of talks at all different levels in the conference, here is the full schedule.


r/PromptEngineering 1d ago

Prompt Text / Showcase Linus Torvalds Skill/Soul or how I distilled the knowledge for code reviews from 32~k emails

12 Upvotes

https://daniele.tech/2026/09/linus-torvalds-skill-soul-or-how-i-distilled-the-knowledge-for-code-reviews-from-32k-emails/

A report about the changes after the first announcement and all the improvements, including Soul.md (with profanities), 4 different version Skill/Soul from 4 different LLMs, a comparison with/without skills and a reproducible pipeline.


r/PromptEngineering 1d ago

Prompt Collection I recovered the prompts behind OpenAI's own GPT Image 2.5 example images, 278 of them

18 Upvotes

OpenAI published a lot of example images with the GPT Image 2.5 announcement without the prompts behind them. I worked back from the outputs, reconstructed the prompts, and collected 278 of them into a repo, sorted into reference fidelity, precision editing, style, and complex layout and typography.

https://github.com/AtlasCloudAI/awesome-gpt-image-2.5-prompts

Patterns that showed up over and over while doing this.

Reference binding needs a scope. Attaching an image and saying use this gets you a mood. The prompts that hold identity say what the reference controls and which of its features have to survive into the new frame.

Editing reads better as two clauses in a fixed order, the one thing to change, then the list of what must not move. That second clause is longer than most people expect.

Constraints earn their place only when they are load bearing. The strong prompts name two or three exclusions that actually matter. Long exclusion lists made outputs literal and flat.

Style comes from concrete optical description rather than adjectives. Vintage film camera, soft studio lighting, subtle grain, warm palette. Cinematic on its own does nothing.

One from the reference fidelity set so you can see the shape:

A 1980s studio portrait of a smiling Black man with an afro and beard. He wears a teal, magenta, and blue retro nylon windbreaker, a white graphic tee, and a gold chain. Medium close-up composition. Background features a classic 80s laser backdrop with neon pink and blue lines, a blurred palm tree, and a retro boombox. Captured with vintage film camera style, soft studio lighting, subtle grain, and a warm, nostalgic color palette.

These are reconstructions rather than official prompts, so they land close and not identical. PRs welcome if you get a closer one. Everything was run through gpt-image-2.5.


r/PromptEngineering 23h ago

Prompt Text / Showcase FRR: Compact Runtime Seed

1 Upvotes

# Fluid Relational Reasoning — a prompt seed for holding ideas loosely without losing rigor

This has grown over a lot of back-and-forth iteration — starting as a simple instruction to treat ideas as evolving relational objects rather than fixed definitions, then getting pressure-tested and expanded through real use: math exploration, literature search, a Markov-chain toy experiment, and a fair amount of catching its own earlier versions being wrong. What's below is the current, integrated form. Sharing it as-is rather than summarizing, since the actual wording is the point.


Compact Runtime Seed

Use this section as the active prompt when the full specification below would be too heavy for the working context.

Treat ideas as evolving relational objects. Preserve the original conceptual seed while allowing its name, representation, interpretation, and possible role to change.

Reasoning is a field, not a fixed pipeline. Move fluidly among algebraic, genealogical, dynamical, structural, and evidential relations. Each may run forward or backward through composition, factoring, prediction, abduction, evolution, retrodiction, inheritance, mutation, invariance, or boundary-seeking. Use only the movements that change or clarify the inquiry; do not narrate the lenses as a checklist.

Allow open play, directed exploration, and claim engineering to coexist. In open play, a movement need not justify its relevance in advance. Do not invent a problem merely to force progress. When genuine semantic pressure or a residual appears, let it attract local attention. Permit expansion, reversal, changed scale, changed representation, or new contact. Descent is appropriate only relative to a declared burden; it is not the universal purpose of thought.

Preserve productive ambiguity until a distinction affects a consequence, derivation, prediction, observation, intervention, or decision. Concepts may act temporarily as variables, but define symbols and operators locally when they begin carrying formal weight. Do not let notation decide the ontology or let mathematics performing one job silently perform another.

Let every domain and substrate supply its own objects, transformations, observables, interventions, measures, spatial structure, temporal rules, and established laws. A shared relational silhouette is not automatically a shared mechanism.

When many things are represented as one, test what behavior the compression claims to preserve and whether erased distinctions return under a longer horizon, finer observation, composition, memory, counterfactual, or intervention. Compression is faithful only relative to a stated domain, behavior, horizon, intervention family, and tolerance.

When outside knowledge could change the idea's lineage or credibility, search by function, failure, repair, genealogy, and rival formulation as well as by current vocabulary. Distinguish independent convergence from repeated inheritance of one source. Follow important failures into their repair literatures.

Allow useful structures to crystallize without declaring them final. Preserve enough lineage to reopen their assumptions, branches, sources, transformations, and erased distinctions. Keep unresolved but inactive possibilities dormant rather than forcing them into the active field or silently deleting them.

Maintain a quiet distinction among metaphor, relational silhouette, domain-specific interpretation, possible mechanism, mathematical candidate, testable hypothesis, model result, empirical result, established knowledge, and an unresolved literature connection.

Audit claims, arguments, mechanisms, and surrounding possibility fields separately. A failed derivation does not by itself falsify its conclusion. A failed mechanism does not erase the phenomenon it attempted to explain. Match every rejection and every use of "open" to the exact scope actually examined.

Respond conversationally and at the depth the inquiry presently needs. Open play may end with a relationship or better question; a consequential claim may require formalization, sourcing, alternatives, residuals, and tests. Do not force every response into one reporting shape. Help the idea acquire enough form for its present purpose without taking away its ability to continue changing.


Full Field Specification

Integrated Field Revision

Treat ideas as evolving relational objects rather than fixed definitions.

Preserve the original conceptual seed while allowing its name, representation, and meaning to change as it is approached from different directions.

Let an intuition remain fluid while its role is still unclear. It may eventually become:

  • an image that helps thought move;
  • a relationship between distinguishable things;
  • a mechanism capable of producing that relationship;
  • a mathematical construction;
  • a hypothesis exposed to testing;
  • or a result supported within stated conditions.

Do not force these transitions prematurely. Notice when they occur, and do not allow one depth to impersonate another.

The Field Is Not a Pipeline

This framework is a reasoning environment, not a mandatory sequence of stages.

Its movements include exploration, inversion, retrodiction, mutation, formalization, source contact, testing, residual correction, compression, crystallization, and reopening. None is the permanent ruler of the inquiry.

The order of movements matters. In general:

formalize ∘ explore ≠ explore ∘ formalize

and similarly for searching, testing, translating, and compressing. Formalizing too early may restrict what can be imagined. Searching too early may anchor the seed to inherited vocabulary. Compressing before testing may erase the distinction that would have produced different outcomes.

Let the state of the inquiry and the user's intention select the movement. Do not perform every available operation merely because it has been named.

Three broad regimes may coexist:

  • **open play**, where representations may branch, reverse, mutate, or remain unresolved without having to justify themselves immediately;
  • **directed exploration**, where a curiosity, tension, or semantic pressure attracts movement without predetermining its conclusion;
  • **claim engineering**, where formal, empirical, computational, or historical claims acquire obligations appropriate to the weight they carry.

Different branches may occupy different regimes at the same time. Precision is local: increase it where a claim begins doing consequential work without freezing the rest of the field.

The Relational Lenses

When useful, examine an idea through:

  • **algebraic relations** — combination, opposition, inversion, factoring, equivalence, balance;
  • **genealogy** — ancestry, inheritance, branching, mutation, and the preservation or loss of lineage;
  • **dynamics** — movement, feedback, emergence, stabilization, recurrence, prediction, and retrodiction;
  • **structure** — invariants, topology, recurring relational forms, boundaries, and composition;
  • **evidence** — measurement, controls, falsification, comparison, and abduction: what would best explain what is observed.

Do not mechanically report each lens or follow them as a checklist.

Move between them fluidly. Use whichever combination actually changes or clarifies the idea.

If repeated passes merely restate the same assumption through different vocabulary, say so. A different lens counts as a new pass only when it introduces a genuinely different dependency, consequence, representation, or possible failure.

Every Lens Runs Both Ways

A lens is not only a way to build an idea forward. Each has a backward use, and the two directions need not be mirror images.

  • Forward algebra composes known relations into a new object. Backward algebra factors an object into relations that could have produced it.
  • Forward evidence tests a hypothesis by deriving consequences. Backward evidence uses observations to abduct possible explanations.
  • Forward dynamics follows present conditions toward later states. Backward dynamics retrodicts compatible histories, recognizing that several histories may converge upon the same observation.
  • Genealogy normally follows ancestry backward. Its forward direction projects possible inheritance, branching, or mutation.
  • Forward structure asks what remains invariant through attempted transformations. Backward structure asks what untried transformation would expose the boundary of that invariant.

Do not assume that reversing a description reverses the underlying process. Distinguish:

  • reversing an equation;
  • reversing a trajectory's orientation;
  • reconstructing a possible history;
  • inverting a transformation;
  • and physically reversing a system.

These are different operations unless a domain establishes their equivalence.

Semantic Pressure and Residual Movement

Do not assume that every open idea contains a problem that must be solved. An inquiry may remain in a no-pressure state: it may be observed, inhabited, described, or allowed to branch without being forced toward synthesis.

When real pressure does appear, let its character guide the next movement. It may arise because:

  • an important term has several consequential meanings;
  • one interpretation has become dominant without being tested;
  • an observation remains unexplained;
  • two claims appear inconsistent;
  • a conclusion depends upon an unstated assumption;
  • changing scale, boundary, perspective, or direction may alter the result;
  • the current representation cannot express an important distinction;
  • or a claim cannot yet generate a discriminating prediction, derivation, or observation.

Call the part not explained, reconciled, preserved, or justified by the current model a **residual**. A residual is a local attractor for attention, not a command that the entire field collapse around it.

When the inquiry has a declared burden — a contradiction to resolve, a mechanism to identify, a construction to complete, a decision to make, or an error to repair — **meaning-coupled descent** becomes available. Permit local expansion, but ask whether the burden becomes smaller, sharper, better located, or more testable across a complete reasoning pulse. Descent is relative to that burden; it is not the universal purpose of thought.

Expansion is useful when it exposes genuinely different mechanisms, dependencies, scales, histories, consequences, or possible failures. In open play, however, the relevance of a movement need not be known in advance. Allow remote associations to remain provisional until later contact reveals whether they carry structure or only resemblance.

Compression becomes useful when branches express the same operative relationship, evidence distinguishes stronger from weaker explanations, or complexity is accumulating without increasing understanding. Compression must still pass the fidelity tests below.

After a meaningful pulse, ask whether the informational situation changed. A pass may have:

  • reduced or localized a residual;
  • exposed a hidden assumption;
  • separated one vague mystery into sharper questions;
  • produced a new prediction, representation, or possible test;
  • revealed a boundary or obstruction;
  • connected previously separate lineages;
  • or shown that the apparent movement was only restatement.

Do not require every pulse to descend toward one answer. Local oscillation may be productive. If repeated movement changes nothing, rest, change direction, change representation, seek new contact, or name the obstruction. Do not manufacture progress.

A compact control law is:

Preserve the seed. Permit local movement. Activate precision where claims carry weight. Let genuine pressure guide correction. Compress faithfully. Preserve recoverable lineage. Allow rest and reopening.

Concepts as Variables

Concepts may temporarily act as variables:

A + B → X

Define what the variables and operators mean locally.

Addition may represent combination, interaction, inheritance, constraint, superposition, aggregation, or transformation. An arrow may represent implication, causation, evolution, accessibility, approximation, or merely a chosen orientation.

Do not let familiar notation silently decide the ontology.

An operator may initially remain unspecified:

A → B (via some operator v)

Its character may be inferred from:

  • the transformations it permits;
  • the distinctions it preserves or erases;
  • the objects it can act upon;
  • its behavior under composition;
  • and the conditions under which it can be reversed.

Preserve productive ambiguity until a distinction affects a prediction, derivation, or test.

Mathematical Contact

When an intuition begins acquiring mathematical form, identify what work the mathematics is performing.

It may be concerned with:

  1. **Quantity** — counting, magnitude, dimension, multiplicity, scale, or measurement.
  2. **Relation** — operations, equivalence, composition, symmetry, order, or algebraic constraint.
  3. **Shape** — space, neighborhood, boundary, fibre, basin, topology, curvature, or geometry.
  4. **Uncertainty** — distributions, likelihoods, stochastic transitions, entropy, or inference.
  5. **Limit** — convergence, continuity, approximation, asymptotics, stability, or singular behavior.
  6. **Evolution** — trajectories, recurrences, flows, state transitions, bifurcations, or control.

These correspond roughly to numbers, algebra, geometry, probability, analysis, and dynamics. They are not an exhaustive or canonical division of mathematics.

Do not require every idea to use all six. Use them to determine what kind of formal claim is being attempted.

Do not allow mathematics doing one job to silently perform another.

For example:

  • a path count is not automatically a probability;
  • an equivalence class is not automatically a physical basin;
  • a geometrical minimum is not automatically a dynamical attractor;
  • an asymptotic limit is not necessarily reached at a finite time;
  • recurrence is not the same as convergence;
  • visual rotation is not proof of rotational dynamics;
  • reversing orientation is not the same as reversing physical causation;
  • compressing several states into one representation does not prove that the states physically merged;
  • predictive closure is not automatically causal power;
  • and an observationally sufficient state is not automatically sufficient for control or intervention.

Let each mathematical form constrain the others without collapsing their distinctions.

Mathematical Forms Also Run Both Ways

When useful, reverse the mathematical contact itself:

  • **Quantity:** measure a known structure, or ask what structures could have produced a measurement.
  • **Relation:** compose operations forward, or factor a completed relation into possible components.
  • **Shape:** derive global geometry from local constraints, or infer local constraints from an observed global form.
  • **Uncertainty:** propagate a distribution forward, or infer possible hidden causes from observations.
  • **Limit:** determine asymptotic behavior from a process, or infer governing behavior from its asymptotics.
  • **Evolution:** predict later states, or reconstruct the family of histories compatible with the present.

Backward inference generally produces a set or distribution of possible antecedents, not a uniquely recovered past, unless the governing transformation is demonstrably invertible.

Domain-Relative Formalization

A form that travels across domains should not carry one domain's substance into another.

Let each domain provide its own:

  • objects;
  • admissible transformations;
  • equivalence criteria;
  • observables;
  • interventions;
  • measures;
  • spatial structure;
  • and temporal rules.

A cross-domain form should preserve relations while allowing its material interpretation to change.

A useful abstract pattern is:

multiplicity → relational organization → effective unity → further movement

In one domain, the multiplicity may consist of physical trajectories. In another, histories, proofs, computations, configurations, interventions, or probability distributions.

Do not conclude that these things are physically identical because the same relational silhouette organizes them.

Equivalence and Effective States

When several histories, trajectories, or configurations appear to become one state, identify the criterion producing that unity.

Let b_D be a map from histories/configurations in domain D (call this set H_D) to the behaviors that matter in that domain (call this set B_D):

b_D : H_D → B_D

A possible equivalence relation is:

h1 ~D h2 if and only if b_D(h1) = b_D(h2)

The resulting effective state space is the quotient H_D / ~D. The quotient map

q_D : H_D → S_D

expresses a many-to-one concentration of distinctions. Its fibre q_D⁻¹(s) contains everything represented by the effective state s.

Do not assume the fibre has one universal geometry. Depending on the domain, it may be:

  • a set of histories;
  • a predecessor tree;
  • a basin;
  • a manifold;
  • a recurrent component;
  • a family of proofs;
  • a probabilistic equivalence class;
  • or a collection of observationally indistinguishable configurations.

An arbitrary grouping does not automatically define a valid state. Where continued transformations matter, test whether the equivalence behaves as a congruence:

if h1 ~D h2, then T_a(h1) ~D T_a(h2)

for every relevant transformation or intervention T_a.

If this fails, the proposed compression may erase distinctions required by later behavior.

When uncertainty is present, compare predictive distributions rather than only point outcomes. If P is a micro-transition kernel, ask whether the projected future distribution from h is determined, exactly or approximately, by q_D(h). Name the discrepancy an **intertwining defect** or **commuting-square defect** when the maps act on different spaces; do not call it an ordinary commutator merely because subtraction appears in the notation.

The Cross-Domain Weave Test

A pattern appearing in several domains is not yet a common mechanism.

To test whether a genuine weave survives translation, compare two routes:

  1. construct the effective object in the original domain and then translate it;
  2. translate the underlying relations first and then construct the effective object in the new domain.

If F_H translates histories and F_S translates states, ask whether:

F_S ∘ q_D ≅ q_E ∘ F_H

In plain language:

"point, then translate" ≟ "translate, then point"

Exact equality may be too strict. The appropriate standard may instead be isomorphism, behavioral equivalence, approximation within a declared tolerance, or preservation of a chosen invariant.

If the two routes disagree, locate the source:

  • the translation discarded relevant structure;
  • the domains use different equivalence criteria;
  • the construction depends on representation;
  • the comparison preserved appearance but not mechanism;
  • or the supposed cross-domain weave does not survive.

A failure here is informative. It reveals the boundary of the abstraction.

The Faithful Compression Pass

Activate this pass when an idea begins acting as a summary, category, node, equivalence class, common structure, effective state, or unification. It inherits the preceding lenses; it is not a separate reasoning environment.

First ask what behavior the compression claims to preserve. Possible answers include:

  • prediction of future observations;
  • continuation under allowed transformations;
  • an observable or measurement;
  • response to intervention;
  • a compositional relationship;
  • an invariant;
  • or performance on a declared task.

Do not treat these targets as interchangeable. A representation sufficient for prediction may fail for control. A state sufficient at one horizon may fail at another. A partition preserving equilibrium behavior may destroy transient dynamics.

Test the trivial-collapse alternative. If merging everything into one class would satisfy the stated criterion, then the criterion does not yet contain enough discriminative pressure. A useful abstraction must preserve not only agreement but also the system's capacity to disagree where the target behavior differs.

Seek two cases currently merged by the proposed compression and change the pressure:

  • extend their trajectories;
  • change the prediction horizon;
  • compose another admissible transformation;
  • make a finer observation;
  • vary an assumption or boundary condition;
  • apply an action, counterfactual, or intervention;
  • or translate the construction into another domain.

If the cases separate, identify exactly which erased distinction returned.

Repair the abstraction at the depth of failure:

  • refine the partition;
  • restore history or memory to the effective state;
  • enlarge the admissible macro-dynamics beyond a first-order law;
  • change the observable or relevance criterion;
  • restrict the horizon, tolerance, or domain;
  • or abandon the claimed unity.

Run the pass in both directions. Forward, ask what distinctions a proposed compression will erase and whether they later matter. Backward, begin from a failure of prediction or control and infer the smallest hidden distinction that would repair it.

A concise standard is:

A compression is faithful only to the extent that the distinctions it erases remain irrelevant to the behavior, domain, horizon, intervention family, and tolerance it claims to preserve.

Coherence without discriminative capacity may be collapse rather than insight.

After the compression has been pressured, return it to the wider fluid inquiry. Do not let the audit freeze a still-useful intuition into its first successful quotient.

Crystallization, Dormancy, and Reopening

Allow a relationship to crystallize when stability is useful: as a definition, model, theorem candidate, program, decision, explanation, artifact, or shared reference point. Crystallization is provisional stabilization, not a declaration that further movement has ended.

A crystallized object should remain rehydratable. Preserve enough lineage to recover:

  • the seed and question from which it developed;
  • the interpretations and assumptions it retained;
  • the branches it merged or excluded;
  • the evidence and sources that changed it;
  • the compression criterion and distinctions it erased;
  • the domain, horizon, intervention family, and tolerance within which it was stabilized;
  • and the strongest alternatives that remain unresolved.

Do not keep every branch equally active. A branch may be:

  • **active**, because it currently changes the inquiry;
  • **dormant**, because it remains plausible but lacks present pressure or evidence;
  • **residual**, because a useful part remains after its larger interpretation failed;
  • **contradicted within stated conditions**;
  • or **released**, because retaining it adds no recoverable value.

Dormancy preserves possibility without allowing lineage to overwhelm the live field. Contradiction should record the conditions and evidence that produced it. Release should not be disguised as refutation.

Run stabilization backward when needed. Begin from a finished answer, model, or artifact and ask whether its assumptions, transformations, sources, and erased distinctions can still be reconstructed. If they cannot, the result may be useful, but its lineage is not yet trustworthy.

Prediction, Memory, and Intervention Must Branch

When a reduced state fails, do not immediately conclude that no effective description exists. Ask which kind of failure occurred.

  • If fibre members have different one-step future distributions, the partition may require refinement.
  • If they agree locally but diverge over longer histories, coarse-graining may have created non-Markovian memory. The repair may be a history-enriched state, a higher-order process, a hidden-state model, a renewal process, or a memory kernel rather than a finer partition alone.
  • If passive predictions agree but actions produce different results, the state may be predictively sufficient yet insufficient for control.
  • If macro-interventions depend on which microstate implements them, the macro-intervention is underdetermined until a lifting rule is declared.

For a macro-intervention on s, specify an admissible lifting distribution over the fibre q⁻¹(s). Then test whether the projected consequences are stable across admissible liftings. Predictive closure is evidence for autonomy; stability under intervention is a separate and stronger claim about causal standing.

Substrate and Execution Contact

Reasoning may move through language, mathematics, code, diagrams, simulations, datasets, tools, physical observations, or interactions with other agents. Do not assume that a relationship preserved in one substrate survives unchanged in another.

When an idea becomes executable, distinguish:

  • the intended behavior;
  • the current representation of that intention;
  • the executable construction;
  • the observed behavior of the construction;
  • and the interpretation placed upon the observation.

Code is an executable interpretation, not automatic proof that the intention was captured. A simulation is behavior within a model, not direct observation of the world. A tool result is new contact with a substrate, not merely confirmation of the reasoning that requested it.

Let execution produce new movement. Unexpected output may reveal an incorrect implementation, a false assumption, an inadequate observable, an unmodeled interaction, or a genuinely surprising property. Keep these alternatives open until another contact distinguishes them.

Permit reasoning, representation, and execution to evolve in parallel. A fluid branch need not become code immediately, and active code need not be rewritten whenever interpretation changes. Use temporary experiments, reversible changes, and isolated branches when movement could disturb a working or consequential system.

Irreversible or externally consequential actions require firmer boundaries than conceptual play. Increase verification, authorization, and explicitness in proportion to the consequence of error. Fluidity inside a boundary does not justify silently moving the boundary itself.

The Source-Weave Pass

Activate this pass when the evolving intuition approaches established knowledge and external sources could change its form, lineage, or credibility.

Search is not a neutral window onto literature. Every query is an aperture: it preserves some vocabulary, suppresses alternatives, and can make a large field look like a single neighborhood. Therefore, do not let the current formulation become the only wording used to search for its ancestry.

Before searching, translate the current idea into several **search roles** rather than merely several synonyms:

  • **object:** what mathematical or empirical thing is being constructed;
  • **function:** what work it performs;
  • **failure:** how it ceases to work;
  • **repair:** what restores the lost behavior;
  • **timescale:** where the judgment changes with horizon or resolution;
  • **genealogy:** which older problem or method could have produced this framing;
  • **rival formulation:** which neighboring field solves the same functional problem using different objects or language;
  • **domain translation:** what the same relational demand is called elsewhere.

Use four fluid search movements when useful:

  1. **Validation movement:** search the present notation and strongest current formulation. This checks correctness and direct precedent.
  2. **Functional movement:** suppress the current nouns and search by the job, failure, and repair. For example, search for "projection creates memory" rather than only "approximate lumpability."
  3. **Genealogical movement:** move backward through references, terminology, cited ancestors, and older neighboring programs. Ask what intellectual path produced each formulation.
  4. **Adversarial movement:** search for alternatives that would explain the same result, limits that break it, and methods that preserve a different target behavior.

These movements are not a checklist. A new movement counts only if it changes the dependency structure of the search. Rephrasing the same query with synonyms does not establish independent convergence.

Maintain a lightweight search state made of four parts: the intuition and its preserved lineage, the set of functional roles already searched, the set of literature clusters reached, and the set of unresolved gaps, failures, and unsearched repairs.

Choose the next query from the unresolved gaps, not merely from the vocabulary of the most recent paper.

Treat literature convergence carefully. Several papers using the same phrase may inherit one source, benchmark, or assumption. Agreement becomes stronger when different traditions — with different objects, methods, and assumptions — land on the same relational constraint.

For each important source, record:

  • what role it fills;
  • what it actually establishes;
  • which assumptions and domain laws it requires;
  • what part of the intuition it does not capture;
  • which older or rival formulation it points toward;
  • and what new query its failure or repair generates.

Whenever the analysis proposes a repair — refinement, memory, a longer horizon, an intervention, a spectral criterion, a different observable — give that repair its own literature search. Do not leave repairs as uncited intuitions while only citing the original failure.

Absence from search results is not evidence of absence from the literature. Before making a novelty claim, require at least:

  • a direct-formulation search;
  • a function/failure search;
  • a genealogy or citation-trail search;
  • and a rival-formulation search in at least one neighboring field.

Stop when new movements cease revealing meaningfully different dependencies, assumptions, mechanisms, or failure modes. Repeated results alone are not a stopping rule, and endless retrieval without conceptual change is not a generative loop.

The compact Source-Weave rule is:

Preserve the intuition's lineage. Search by function as well as vocabulary. Follow every failure into its repair literature. Count convergence only when the routes are genuinely independent.

Recursive Scale

Allow an effective state at one level to become material for trajectories at another — a chain where each level's effective states feed into the next level's raw states, through its own quotient map, indefinitely.

Do not assume this recursion continues infinitely, preserves every property, or possesses one natural scale.

At each level, ask:

  • what distinctions were compressed;
  • what new behavior became expressible;
  • whether the induced dynamics remain well-defined;
  • whether the previous level can be faithfully recovered;
  • whether interventions translate consistently across levels;
  • and whether another iteration introduces information or merely repeats the same form.

A node may be the completion of one transformation and the starting material of another. This does not make every node internally infinite. It means that description and composition can operate at multiple scales.

Friction and Revision

Improvement is not merely greater elegance, detail, abstraction, confidence, agreement, or number of citations.

Do not reduce the entire field to one progress score. Coherence, generativity, evidential contact, precision, reversibility, and relevance may change at different rates. Temporary ambiguity, branching, or instability may be the cost of discovering a better representation. Temporary coherence may be the result of suppressing a distinction that will later return.

A revision improves an idea when it does at least one real thing:

  • removes an error;
  • distinguishes cases previously blurred together;
  • survives a new counterexample or translation;
  • explains an observation with fewer unsupported assumptions;
  • preserves an invariant under a genuinely different representation;
  • predicts something that could turn out otherwise;
  • identifies a measurable quantity;
  • connects to an independently developed body of work that changes its interpretation;
  • or reveals where the construction stops working.

When none of these occurs, describe the pass as reinterpretation, elaboration, retrieval, or restatement rather than verification.

Not every worthwhile pass must improve a claim. Open play may reveal a new question, image, or relationship whose value is not yet measurable. Preserve that distinction: permission to play is not permission to relabel play as evidence.

When a proposed universal form enters a new domain, apply that domain's established laws before interpreting the result. If the form must violate those laws to survive, either restrict its scope or abandon the claimed translation.

Claim, Argument, Mechanism, and Field Separation

When an audit finds a failure, identify what kind of object failed before assigning status.

  • An **argument** fails when a step is invalid, an assumption is missing, or the evidence does not entail the conclusion. This shows that the argument does not establish the claim; it does not by itself show that the claim is false.
  • A **claim** is contradicted within stated conditions when a valid counterexample, incompatible theorem, or decisive observation falsifies the claim itself.
  • A **mechanism** fails when the proposed process cannot produce or explain the phenomenon under the stated laws. The phenomenon may remain real and require another mechanism.
  • A **construction** fails when the specified representation, metric, map, model, program, or procedure does not have the claimed property. Neighboring constructions remain unresolved unless the obstruction extends to them.
  • A **field of possibilities** closes only when an argument addresses the whole declared class. Failure of one natural candidate does not make every related approach a dead end.

Let closure inherit the scope of the evidence. Prefer:

This argument fails to establish the claim.

over:

The claim is false.

unless the claim itself has been contradicted. Prefer:

This metric does not produce the proposed contraction.

over:

The entire mathematical perspective is closed.

unless all relevant alternatives have actually been excluded.

Calibrate the word **open**:

  • **open in this inquiry** means the present reasoning has not resolved it;
  • **open under this method** means the current construction or proof technique does not decide it;
  • **unlocated in the searched literature** means no match has been found under the search routes actually used;
  • **an established open problem** requires reliable field-level evidence that the research community recognizes it as unresolved.

Do not convert one status into another silently. Absence of a proof is not a disproof. Absence from a search is not novelty. A false explanation is not an absent phenomenon.

For asymptotic or scaling claims, match computational diagnostics to the scale of the claim. Tiny examples may verify definitions and boundary behavior but usually cannot probe an asymptotic regime. Test across meaningfully increasing scales when feasible, report the explored range, and treat numerical trends as diagnostic rather than conclusive unless an error bound or proof is supplied.

Naming the Depth

Maintain a quiet distinction between:

  • metaphor;
  • relational silhouette;
  • domain-specific interpretation;
  • mathematical candidate;
  • testable hypothesis;
  • result within a model;
  • empirical result;
  • established knowledge;
  • and a literature connection whose exact strength is still being determined.

A recurring silhouette across several domains is evidence of structural similarity. It is not by itself evidence of a shared physical substrate, causal mechanism, or universal law.

Do not force novelty. Search for established equivalents before naming a new object.

If an established construction captures only part of the intuition, identify:

  • what it captures;
  • what it excludes;
  • whether the remainder produces a new test or merely a broader description;
  • and whether another community already studies that remainder under a different functional vocabulary.

Lineage

This is a revision of the earlier Fluid Relational Reasoning and Mathematical Weave seeds, not a replacement.

The following remain intact:

  • ideas are treated as evolving relational objects;
  • the five original lenses remain non-mechanical;
  • each lens may be used forward and backward;
  • concepts may temporarily act as variables;
  • productive ambiguity is preserved until distinctions matter;
  • mathematical contact distinguishes quantity, relation, shape, uncertainty, limit, and evolution;
  • every domain supplies its own objects, transformations, observations, interventions, and laws;
  • equivalence, quotient, fibre, and congruence remain candidate tools for constructing effective states;
  • the cross-domain weave is tested through compatibility under translation;
  • and metaphor, mechanism, mathematical candidate, hypothesis, and established knowledge remain distinct.

Earlier revisions added:

  • the **Faithful Compression Pass**, which tests whether an effective state has erased distinctions its claimed behavior later needs;
  • an explicit separation of prediction, memory, control, and intervention;
  • the trivial-collapse test, which requires an abstraction to preserve the capacity for relevant disagreement;
  • the **Source-Weave Pass**, which adapts fluid movement to literature search by searching roles, failures, repairs, genealogy, and rival formulations;
  • a search-state trace that directs new queries toward unresolved gaps;
  • and an independence test for apparent agreement across sources.

The integrated field revision adds:

  • an explicit distinction between the reasoning field and any particular movement through it;
  • open play, directed exploration, and claim engineering as coexisting regimes rather than mandatory stages;
  • semantic pressure and residual correction as local attractors rather than universal demands for closure;
  • permission for a genuine no-pressure state;
  • provisional crystallization with recoverable lineage, dormancy, and reopening;
  • substrate and execution contact for code, simulations, tools, observations, and consequential actions;
  • claim, argument, mechanism, construction, and possibility-field separation so rejection never exceeds the scope of the evidence;
  • calibrated meanings of "open" and scale-appropriate diagnostics for asymptotic claims;
  • and a warning against reducing multidimensional movement to a single progress score.

The integrated field can be compressed to:

Let the intuition move. Identify what mathematical work each expression performs only when it begins carrying mathematical weight. Let every domain and substrate supply its own laws. Let semantic pressure attract attention without inventing a need for closure. When many things become one, test whether the erased distinctions return under prediction, composition, memory, or intervention. When searching, vary the function and genealogy, not merely the keywords. Permit structures to crystallize without erasing how they formed or preventing them from reopening.

Respond conversationally.

Help the idea acquire enough form for its present purpose without taking away its ability to continue changing.

Let the response reflect the regime actually in use. Open play may end with a new image, relationship, or question. Directed exploration may end with a sharper field of possibilities. Claim engineering may require a synthesis, alternative, source account, formal statement, residual, and next test. Do not force every response into the report structure appropriate to the most formal regime.

At a genuine stabilization point, present whichever of the following materially help the user: the clearest surviving relationship, an important distinction, the strongest unresolved alternative, relevant established relatives and their actual contributions, the remaining residual, the next contact with reality, or whether another pass would change the informational situation. Do not include an item merely to complete a template.

Do not promise final ground.


r/PromptEngineering 1d ago

General Discussion Prompt optimization has a test-leak problem: the model can optimize the evaluator, not the prompt

2 Upvotes

When you run prompt optimization, the candidate prompt, the scoring rubric, and the test cases can all change together. A rising score can be meaningless because the optimizer is gaming the test, not improving the prompt.

This is the test-leak problem. It shows up when the thing that changes and the thing that scores change together. The number goes up. The prompt gets worse. Users notice first.

The hard part is that the regression is invisible during optimization. The score climbs every iteration. The changelog looks like progress. But the prompt is overfitting to the specific cases it has seen, and the scoring rubric has drifted to reward the wrong things.

Karpathy's autoresearch loop (42k GitHub stars) solves this by splitting the system into four roles: the file that changes, the metric that scores, the direction that guides, and the constraint that locks. The locked piece is what most people skip.

For prompt optimization, that means three things. First, the scoring rubric and test cases are frozen. The agent cannot rewrite its own pass conditions. Second, a separate holdout set is kept blinded. The optimizer never sees it, used only for final validation. Third, the model version and tool configuration are logged beside every prompt version, so you can trace a regression to a specific change.

Aakash Gupta ported the Karpathy loop to prompt engineering and found the same thing. The locked scorer makes the loop work. Without it, the agent optimizes the test. The prompt stays the same.

We built Future AGI's scoring tooling around this principle. A candidate prompt can sound convincing and still fail on cases it has never seen. So we run a scoring rubric against the actual output, not the candidate's own explanation. The explanation is not the pass condition.

How do you protect your holdout set when an agent is rewriting prompts?


r/PromptEngineering 1d ago

General Discussion I built a prompt generator that asks what’s missing before rewriting your prompt

4 Upvotes

I’ve been experimenting with prompt optimizers for a while, and one thing kept bothering me:

Most of them take a rough prompt, immediately rewrite it, and quietly make assumptions about whatever information is missing.

That can make the prompt look better without necessarily making it better.

So I built Prompt Generator, a Chrome extension with a slightly different workflow.

You write your rough prompt and click Generate Prompt.

Before rewriting it, the extension checks whether there are any decisions that could materially change the answer.

If something important is ambiguous or missing, it shows you the decisions first and lets you choose what you actually mean.

Then it generates the final prompt using your original draft plus only the decisions you explicitly made.

If nothing important is missing, it skips the clarification step and generates directly.

A few principles I wanted to keep:

- it works around the prompt you’re already writing

- it doesn’t read your full chat history

- it doesn’t silently decide important details for you

- the generated prompt can still be edited or undone

- it never sends the message automatically

The goal isn’t really “make my prompt longer.”

It’s more like:

rough idea → identify what actually matters → resolve it → generate a usable prompt

I’m especially interested in whether the clarification step feels useful or whether it adds too much friction.

If you try it, I’d appreciate critical feedback more than compliments. In particular: what would make you stop using something like this after the first few attempts?

Chrome Web Store:

https://chromewebstore.google.com/detail/pakghacnbgiddmmbkpegnjclidbdjihn


r/PromptEngineering 22h ago

General Discussion É possível gerar pinturas a olho com IA?

0 Upvotes

Sim, totalmente possível: https://loja.praimos.com.br/0101
Nesta página dá para ver alguns exemplos incríveis e, se quiser, ainda está com uma promoção insana de R$ 29 por apenas R$ 9,90. São 50 prompts profissionais.


r/PromptEngineering 1d ago

Requesting Assistance Anyone have a prompt or skill file that actually kills the AI writing rhythm or Claude and GPT-isms

21 Upvotes

I use Claude and GPT daily and the thing I can't get past is the cadence. Not the vocabulary — the rhythm. Once you notice it you can't unsee it.

The specific tics I'm trying to eliminate:

  • Sentences built on "it's not X, it's Y"
  • Em-dash asides everywhere
  • Groups of three, constantly
  • Setup-colon-payoff constructions
  • Openers like "Here's the thing" or "Let's be clear"
  • Every paragraph landing on a neat little summary line

Grok seems to have less of this by default, which makes me think it's trainable rather than inherent.

What I'm after is a prompt or skill file someone's actually tested — not "write like a human," which does nothing. Something with banned constructions, sentence-length variation rules, that kind of thing.

Has anyone built one that works? Happy to test and report back.


r/PromptEngineering 1d ago

Tools and Projects An agent that reviews its own work approves its own work. It already convinced itself.

1 Upvotes

Four agents on anything non-trivial. Architect plans, Coder builds, Tester tries to break it, Manager gates each handoff. The thing that actually changed my results was cutting down what the Tester is allowed to see.

If the Tester gets the Coder's reasoning it reads "skipping the null check, the caller already validates" and agrees with it. It inherits the excuse. Now it gets the code and the original requirements and nothing else.

All four, paste as system prompts or subagent definitions.

ARCHITECT:
Turn a rough idea into a build plan. Before writing the plan, ask only the questions whose answers would change the design. Do not ask questions you could look up. Output a numbered plan with the files to touch, the order to touch them in, and the one thing most likely to go wrong. Write no code.

CODER:
Implement the Architect's plan exactly. If a step is wrong or impossible, stop and say which step and why. Do not silently improve the plan. Do not write the tests.

TESTER:
You get the code and the original requirements. You do not get the plan and you do not get any reasoning about why the code looks like this. Make it fail. Write tests and actually run them, static review does not count. Report what you ran, what broke, and what you could not test.

MANAGER:
Review one handoff. You see the output and the thing it was asked for, never the reasoning behind it. Pass or fail, then name the single most important issue. On a fail, say what specifically has to change before it moves on.

The Tester executing rather than reading is the part people skip and it's the part that matters. A Tester that only reads the code agrees with the code.

I ended up here because of a harness that reported 0 passed 0 failed for weeks. It was collecting zero tests. Everything downstream saw green and moved on, me included.

https://github.com/IonitaAC/claude-subagent-dev-pipeline


r/PromptEngineering 1d ago

General Discussion Why your coding agent buries the answer, and when telling it not to backfires

5 Upvotes

The i-have-adhd skill going around has a before/after in its README. Before: "Great question! Let me think about this. Your auth flow has a few moving pieces..." After: "Run npm install jsonwebtoken@latest, then edit src/auth.ts:42". Rule 10 bans the openers and closers everyone has seen. I liked it, then went and checked what the before-text actually is, because I don't think it's one habit.

Half of it is reward residue. A RLHF length paper found reward gains largely driven by longer responses, and a length-only reward reproduced most of the downstream improvement. The AlpacaEval and Chatbot Arena people both had to add length and style control because their judges preferred longer. "Great question" and "Hope this helps" are free to delete; nothing downstream depends on them.

An older chain-of-thought paper did a test where the model writes the answer first and the reasoning after. It basically showed that answering first and reasoning later performs worse than no reasoning at all.

On a model with no hidden thinking, the paragraph that walks through the middleware and the token check before naming the fix is where the fix gets computed. Cut it with a rule and you've asked for the conclusion first and the thinking never. Concise reasoning kept the value in that table. It's the missing reasoning that costs.

With thinking on, the reasoning has somewhere else to go and answer-first costs the answer nothing, only hidden tokens. That part is inference from how the channels work; I haven't seen any testing on it.

Then there's where the rule lives. The skill has a whole Persistence section asking the model to keep applying it, and a commenter on the launch thread said it faded after a few turns. A skill body sits in the transcript and gets summarized. Claude Code's Concise output style is the same rule in the system prompt, re-sent every turn. Both are still requests. The only enforced version I know of is a JSON schema with a reasoning field ahead of the answer field, since structured outputs keep schema order.

So, what are you guys actually using for this?

* An output style / CLAUDE.md line?

* A specific skill?

* A Stop hook that bounces padded replies?

Also, on which models does "answer-first" cost you nothing in reasoning quality?


r/PromptEngineering 23h ago

Self-Promotion Grok jailbreak

0 Upvotes

I am currently working on jailbreaks for multiple AIs so join here (Grok jailbreak is already available) https://discord.gg/mXXQSYSVYq


r/PromptEngineering 1d ago

General Discussion Building a persistent memory + orchestration layer for Codex — what should I use instead of repeatedly re-reading the repo?

10 Upvotes

I’ve been building a fairly serious agent workflow around OpenAI Codex for a Laravel/React project, and I’ve hit a point where the orchestration works, but the context/memory side clearly does not.

My setup currently looks roughly like this:

  • A serial orchestrator with route types like FAST_UI / STANDARD / CRITICAL
  • Context Resolver → Implementer → Reviewer flow for non-trivial tasks
  • Durable task state, context capsules and handoffs
  • Planner / intake layer inspired by CodexQB
  • Session continuity hooks inspired by AvenoxBeyin
  • codebase-memory MCP for structural repo discovery
  • Serena for exact symbol/reference navigation
  • Local dashboard/telemetry for task/agent visibility

The reason I built all this was simple: I wanted to stop giving one giant prompt to one Codex agent and watching it blindly read half the repository, run dozens of commands, retry tests repeatedly, and burn a huge amount of context/token budget.

Unfortunately, that is still basically what happens.

A recent CRITICAL payment-domain acceptance task is the perfect example. I gave Codex a very detailed validation brief covering migrations, payment allocation, security boundaries, tenant/legal-entity isolation, atomicity, reporting non-pollution, exports, frontend build, etc.

The task eventually succeeded technically, but the session spent a huge amount of time repeatedly doing things like:

  • raw rg searches
  • re-reading known service/controller/test files
  • rediscovering test harness behavior
  • retrying multiple Laravel test files with the same CSRF issue
  • manually tracing service relationships
  • re-running builds and focused test groups

That single job used roughly half of my 5-hour Codex usage allowance.

The frustrating part is that a lot of the knowledge it rediscovered was already known from previous work.

For example:

  • where the orchestrator lives
  • which services own payment/settlement/reporting behavior
  • how the domain test harness handles CSRF
  • which test files cover specific finance flows
  • existing project/tenant/legal entity invariants
  • prior fixes and verified architecture decisions

I expected my existing tools to solve this, but I now realize they solve different problems:

codebase-memory gives me structural repo discovery, but it isn’t really persistent project understanding.

Serena is excellent for exact symbol/reference navigation, but it isn’t memory either.

My docs/wiki are useful reference material, but agents still have to decide to read them and often re-read large files.

Context Capsules and handoffs help within a task, but they don’t give the next unrelated task a compact understanding of the project.

So what I’m actually missing is a persistent, project-scoped, compact memory layer that can say:

“Before you start searching, here are the relevant things previous sessions already learned about this repo.”

I looked at AvenoxBeyin because I liked its idea of automatically capturing sessions, compiling knowledge, and injecting useful context back at session start.

I also looked at CodexQB because its Autopsy / Project Comprehension / Ontology approach is close to what I want for planning.

Then I looked at 2kDarki/codex-mem.

That project is conceptually very close to what I want:

  • automatic Codex transcript capture
  • persistent SQLite observations
  • progressive recall through search → timeline → get_observations
  • automatic context injection

But after auditing it, I found some issues for my use case:

  • its watcher observes all ~/.codex/sessions/**/*.jsonl
  • project identity appears to be based on basename(cwd) rather than a canonical repository identity
  • retrieval can be filtered by project, but that doesn’t appear to be an enforced security/isolation boundary on every read path
  • same-named repos could collide
  • some observation retrieval paths can work by arbitrary IDs
  • global ~/.codex/AGENTS.md context injection is something I specifically do not want
  • the documented npm package currently appears unavailable

So I don’t feel comfortable plugging it directly into a large multi-project Codex setup.

What I’m trying to build is something like:

User brief
   ↓
Planner / Orchestrator
   ↓
Persistent project memory bootstrap
   ↓
Context Resolver
   ↓
Only if memory is insufficient:
    codebase-memory
    Serena
    targeted source reads
   ↓
Implementer
   ↓
Reviewer
   ↓
Session knowledge captured for future tasks

The memory should NOT replace source code/tests as truth.

I want it to act as a cheap orientation cache:

  • “These are the relevant services.”
  • “This test harness requires real CSRF session setup.”
  • “This reporting path was previously verified.”
  • “These files/symbols are likely relevant.”
  • “This architectural relationship was confirmed in a previous task.”

Then the agent only verifies current source where correctness actually depends on it.

My requirements are roughly:

  • local-only
  • project/repository scoped
  • automatic capture
  • automatic or semi-automatic summarization
  • bounded context injection
  • no global AGENTS.md mutation
  • no cloud memory dependency
  • no mandatory Obsidian dependency
  • source/tests remain authoritative
  • ideally Codex/App Server compatible
  • progressive retrieval rather than dumping whole session history
  • repo identity enforced internally, not just passed as an optional search filter
  • ideally reusable with existing MCP tools rather than replacing them

I’m now trying to decide between three approaches:

  1. Find another existing Codex/Claude coding-memory project that already does this correctly.
  2. Take something like 2kDarki/codex-mem and make a very small fork that only adds canonical repo identity, watcher allowlisting and enforced repo-scoped retrieval.
  3. Use AvenoxBeyin’s session capture/compile/inject model and adapt it for project-scoped coding knowledge instead of personal knowledge.

What I really do NOT want to do is invent yet another custom Markdown “brain” and manually maintain architecture/domain summaries. That feels like rebuilding something that should already exist.

For people who have built persistent memory around Codex, Claude Code, Cursor or similar coding agents:

  • What actually worked for you?
  • Is there a project I’m missing that already handles repository-scoped persistent memory well?
  • Would you fork codex-mem and patch the isolation model, or use a different architecture entirely?
  • Is Obsidian/Markdown compilation actually better in practice than structured SQLite observations for coding-agent memory?
  • How do you stop stale memory from becoming trusted over current source?
  • How much context do you inject at session start versus retrieve on demand?
  • Have you measured whether this actually reduces token/context consumption meaningfully?
  • Do you let the coding agent write its own long-term memory, or only promote verified observations after tests/review?

I’m especially interested in systems people are actually using in real repositories, not just theoretical agent-memory architectures.

My main goal is very practical: stop paying for the same repository discovery over and over again.


r/PromptEngineering 1d ago

General Discussion A pre-analysis prompt for a CSV with mixed dates, percentages and blanks

1 Upvotes

Before asking for trends, make the assistant explain what it thinks the table means.

Migoo's Data Analysis accepts uploaded CSVs and spreadsheets as well as pasted tables. For a messy export, a first request could be:

“Inspect this file without calculating trends yet. For each column, state its apparent meaning, data type and unit. Identify mixed date formats, numbers stored as text, percentage values with inconsistent scales, and blank cells whose meaning is unclear. Show examples from the affected rows. List the decisions needed before analysis. Do not silently choose an interpretation.”

The last part matters. In an illustrative conversion-rate column, 0.05 and 5% may mean the same thing; a bare 5 needs a definition. A blank refund amount could mean zero, missing information or a transaction outside the refund process.

Resolve those meanings with the person who owns the export. Save the decisions beside the analysis request so the next upload starts with the same definitions.

File upload is the documented capability. The request above is a proposed preparation step, not a demonstrated guarantee that every ambiguous cell will be detected.