Tooling 'Multi-AI Comparison with the Same Prompt' — Releasing SRP Skill Files

Key points of this article: Many people already "send the same prompt to multiple AIs to compare results." SRP (Stochastic Resonance Prompting) turns this into a methodology, which I have now implemented and released as custom skills for Claude Code. There are two versions: a manual version (/srp, zero external dependencies) and an automatic version (/quick-homo-srp, executed in parallel via Codex CLI).

Introduction — More people are doing this

Recently, I saw this tweet on X:

I was manually asking both Claude and Codex to review my code, so I made a command to get review or refactoring suggestions in 4-way parallel (Opus 4.6, Opus 4.5, Codex 5.3, Codex 5.2).
— @634kami (2026-02-07)

Sending the same task to multiple AIs and comparing the results. When you try it, you realize something—if you only ask one model, you can't even notice that "other options existed" in the first place.

In June 2025, I named this practice Stochastic Resonance Prompting (SRP) and wrote an article about it on note. However, just giving it a name wasn't enough. Manually copy-pasting for several parallel runs is too tedious to fit into a daily workflow.

What I did this time was implement SRP as Claude Code custom skills so that it can be run with a single command. It might be a bit cliché, my apologies.

In this article:

1. I briefly introduce the philosophy of SRP.
2. I release the skill files for the manual version (/srp) and the automatic version (/quick-homo-srp).
3. I explain the design considerations.

The skill files are available on GitHub.

---

What is SRP?

There is a phenomenon in physics called Stochastic Resonance. It's a counter-intuitive phenomenon where adding noise to a weak signal actually makes the signal easier to detect.

SRP applies this concept analogously to LLM prompting (though there isn't a strict mathematical correspondence).

By sending the same prompt to multiple AIs and comparing the probabilistically fluctuating outputs, structures that are invisible to a single AI are brought to the surface.

The important thing here is that SRP is not a method for directly producing a "better answer."

• If four AIs say the same thing, that is a strong consensus.
• If only one says something different, it's a branch point worth considering.
• Sometimes the consensus is correct, and sometimes the essence is hidden in a single deviation.
• It is the human's domain knowledge that makes the final call.

If you don't compare, you won't even realize that there were choices—this is the core of SRP.

Detailed principles and practical examples of SRP are written in past articles. This article focuses on releasing it as a "tool you can use."

---

/srp — Manual Version

First, the manual version. It has zero external dependencies (no Codex CLI or API keys required). The output is just a Markdown file, so you can copy and paste it to use with ChatGPT Free, Gemini, or Claude.

How it works

When you type /srp during a Claude Code session, it analyzes the conversation history and generates a self-contained prompt that can be distributed to other AIs. Think of it as "crystallizing" the discussion from the session into a single prompt.

The receiving AI has no context of the current session, so all necessary information must be packed into the prompt. Doing this manually is a chore, but /srp handles it for you.

8-Section Structure

The generated SRP prompt has the following structure:

Section	Content	Common/Unique
§1 Objective	Purpose of the task	Common
§2 Background	Domain knowledge and context	Common
§3 Scope	What to do and what not to do	Common
§4 Constraints	Constraints	Common
§5 Input Materials	List of files to read	Common
§6 Guiding Questions	List of questions to answer	Common
§7 Deliverable Spec	Specifications for the output	Common
§8 Output Instructions	Destination, sequence number, model name	Unique

Sections §1 to §7 are common to all models; only §8 differs. We do not customize the prompt for each model. This is a major principle of SRP. The reason for this will be discussed later.

Distribution via One-liners

Once the prompt is generated, one-liners for passing it to each AI are output:

#01 gpt_5.2:
Read srp_sessions/20260208_topic/20260208_topic_srp.md and
execute the task described there.
Your sequence number is 01, and your model name is gpt_5.2.

#02 gemini_3.0_pro:
Read srp_sessions/20260208_topic/20260208_topic_srp.md and
execute the task described there.
Your sequence number is 02, and your model name is gemini_3.0_pro.

#03 claude_opus_4.6:
(and so on)

You just copy and paste these into each AI's interface. Any coding agent that can access the file system (Claude Code, Codex CLI, Gemini Code Assist, etc.) will work.

---

/quick-homo-srp — Automatic Version

If you've read this far and thought, "Wait, manually copy-pasting four times is a pain," you're right.

/quick-homo-srp automates everything from SRP prompt generation to parallel execution. It uses the Codex CLI to run N instances simultaneously in the background.

It uses the Codex CLI's --full-auto option (which allows automatic writing to files in the workspace). For details on the risks and mitigation measures, please refer to the "Commands executed internally" section below.

For the reasoning effort level, the Codex CLI default is used unless specified. The author's recommendation is xhigh. If you let the AI agent handle the automatic installation, you will be asked about this setting.

Usage

/quick-homo-srp calculator_redesign

With just this:

1. Generates an SRP prompt from the session discussion
2. Launches 4 instances of the Codex CLI default model in parallel
3. Monitors and reports the completion of each instance

The model and number of instances can be changed using natural language:

/quick-homo-srp calculator_redesign 3
/quick-homo-srp @existing_prompt.md gpt-5.2 x3
/quick-homo-srp calculator_redesign in English

Generate mode and File mode

Mode	When to use	How to launch
Generate	To run SRP on the discussion in the session	Execute normally without @
File	To reuse an existing prompt	Specify with @path/to/prompt.md

File mode is surprisingly useful. You can use it when you want to "tweak the previous SRP prompt a bit and run another round."

Required Environment

• Codex CLI: OpenAI's CLI tool
• Authentication: Automatic authentication via subscription (ChatGPT Plus/Pro/Team/Enterprise) or the OPENAI_API_KEY environment variable

Commands executed internally

The following is executed in each instance:

codex exec --full-auto \
  -C "/path/to/project" \
  -c model_reasoning_effort="xhigh" \
  - <<'PROMPT_EOF'
[Full SRP prompt text + instance-specific §8]
PROMPT_EOF

Option	Meaning
exec	Non-interactive mode
--full-auto	workspace-write sandbox + automatic approval (convenience preset)
-C	Working directory
-m	Model specification (defaults to Codex CLI default if omitted)
-c model_reasoning_effort	Reasoning level (medium / high / xhigh)
-	Read prompt from stdin

--full-auto is a preset (shortcut) for the workspace-write sandbox + on-request approval. In SRP, we further constrain the output destination to a session folder via the prompt to reduce the risk of breaking existing files. However, since prompt constraints are not enforceable, humans should audit the final deliverables and any changes.

Note that the behavior of --full-auto may change depending on the version of Codex CLI. Please check with codex --version.

---

Design Philosophy — Lessons Learned from Real-world Use

The design of the skill files incorporates lessons learned from extensively using SRP in actual projects.

1. Same prompt to all AIs

We do not customize prompts for each model.

If you make adjustments like "be detailed for GPT, be concise for Claude," you won't be able to distinguish whether the difference in output is due to the "model's personality" or the "difference in prompts." Since the value of SRP lies in comparing probabilistic fluctuations, we intentionally keep the input unified.

2. Thin-session guard

If you run SRP in a session with a thin discussion, you will just get four sparse prompts generated, resulting in four sparse outputs.

I have included a guard in the skill file: "If §2 Background cannot be filled with project-specific content, warn the user." Quadrupling garbage doesn't turn it into gold.

3. Free Commentary mandatory

In the §7 deliverable specification, Free Commentary is mandatory.

When you only have answers to structured questions (§6), the outputs tend to converge. Models get stuck in patterns like "I should answer Question 1 like this." By forcing free commentary, space is created for the AI to write about "things that weren't asked but caught its attention."

In my previous article, comparing structured outputs (Top 5 rankings and score distributions) led to discoveries like a consensus on "437" and ceiling effects. The structured questions in §6 are a device for "aligning and comparing along the same axes," having high detection power for consensus and branching. On the other hand, the §7 Free Commentary is a place to pick up "perspectives that weren't asked about"—the discovery of the axes themselves. Having both expands the surfaces where fluctuations can manifest.

4. Artifact Safety

All SRP outputs are written to a session folder. Direct writing to production paths is prohibited.

It would be disastrous if four AIs overwrote the same project file simultaneously. Outputs are isolated in the session folder, to be moved to production only after a human audit. This process might seem tedious, but it's much cheaper than crying after an accident happens.

5. Artifact Naming Convention

YYYYMMDD_{name}_{NN}_{MODEL_NAME}.{ext}

With the three elements of date, sequence number (NN), and model name, you can uniquely identify when, by which model, and in which run a file was created. It won't collide even with multiple runs of the same model.

6. Limitations — You Can Go One Step Ahead, but Not Two

SRP is a method to amplify domain knowledge, not to replace it. Things you "kind of understand but haven't verbalized" (one step ahead) can be visualized through SRP comparisons. However, in areas where you "don't even know what you don't know" (two steps ahead), even lining up four outputs won't help you judge which branch is essential. Just like stochastic resonance, if there is no input signal, only noise gets amplified.

---

How to Install

0. Let Claude Code do everything in the first place

You can install it simply by asking Claude Code like this:

Download the SRP skill files from https://github.com/chemica-tan/stochastic_resonance_prompting and place them in .claude/skills/

1. Place the files

If you want to do it manually, download the files from the GitHub repository and place them in the .claude/skills/ directory of your Claude Code project:

.claude/skills/
├── srp/
│   ├── SKILL.md
│   └── commands/
│       └── srp.md
└── quick-homo-srp/        # Optional if you don't need the automatic version
    ├── SKILL.md
    └── commands/
        └── quick-homo-srp.md

2. Restart and execute

Once you restart Claude Code (or start a new session), /srp and /quick-homo-srp will be recognized as slash commands.

Customization Points

Item	Default	Where to change
Output path	srp_sessions/	Path definition in commands/srp.md
Default model	Codex CLI default x4	Default values in commands/quick-homo-srp.md
Language	Japanese	Language section in each commands/*.md

The most common customization is changing the path to match your project structure. Search for srp_sessions inside the skill files and rewrite it to your preferred path.

Full skill files:
👉 https://github.com/chemica-tan/stochastic_resonance_prompting

---

FAQ

Q: Does diversity emerge from the same model × 4?

Yes, it does. Especially in tasks with high degrees of freedom, you get plenty of diversity. In my previous article, four instances of the same model produced four different definition names, four different formulas, and four different "Top 1" results. The probabilistic nature of LLM generation naturally ensures diversity.

Sometimes I intentionally mix different models. However, my personal feeling is that whether you have a good SRP prompt prepared has a greater impact on the result than the choice of models. Even with the same model, you get enough differences. For tasks where you want to reduce mistakes like a "Swiss cheese model," the same model is sufficient; if you want to expand the search space for free commentary (§7), mixing heterogeneous models is also a strong option—though this is still at the stage of heuristics.

Q: Isn't it 4x the cost?

Since it's parallel execution, the time required is almost the same as one run. In many cases, running it four times from the start is more efficient than repeating "single run -> dissatisfaction -> redo."

Q: Is the integration of results manual?

Yes, basically, a human reads and judges. Of course, you can ask an AI to "read these four reports and create an integrated report," but it's better for a human to intervene where domain judgment is involved. In fact, once you see the comparison results, you will probably want to intervene.

Q: What kind of tasks is it suitable for?

Open-ended tasks with no single correct answer. Design reviews, refactoring strategies, drafting specifications, planning. Conversely, it's a waste for deterministic tasks like sorting or calculation.

In my case, I use it frequently for tasks like converting atom combination rules written in chemical engineering papers into SMARTS (molecular structure pattern notation). SRP is suitable for tasks where "specifications are written in natural language, but the correctness of the conversion must be strictly verified."

Q: How to choose between /srp and /quick-homo-srp?

Start with /srp (manual version). It has zero external dependencies and lets you experience the concept of SRP. Once you feel that "copy-pasting is a pain," it's natural to move on to /quick-homo-srp (automatic version) to automate the parallel execution.

Q: Any guarantee it won't change existing code?

In the design of the skill files, we impose constraints via prompts such as isolation to session folders, naming conventions, and prohibition of changing existing files. However, since prompt constraints are not absolute, humans must ultimately audit the output before reflecting it in production.

Q: Can it be used outside of Claude Code?

The manual version /srp generates a plain Markdown file. You can use it with any AI by copy-pasting. The previous note article was done entirely by manual copy-pasting. The automatic version /quick-homo-srp depends on the Codex CLI, but in principle, the same thing can be done with any CLI tool. You can probably get an AI to help you implement it.

---

Past Articles

Origins and practical examples of SRP:

1. [note] Stochastic Resonance Prompting: An AI-Collaborative Refactoring Method That Even a Beginner Achieved 1550 Lines to 950 Lines in 50 Minutes (June 2025) — The debut of SRP. A story of the author, an R beginner of three months, refactoring with AI collaboration (1550 to 950 lines, 50 minutes, $1.83). At the time, it was written as "Step-by-step Prompting," and the emphasis was slightly different from the current "Parallel Comparison" framework.
2. [OpenAI Community] Technique Share: SRP — How I Used LLM "Noise" to Sharpen My Code (July 2025) — English version of the note article. Shared with the OpenAI community.
3. [Zenn] Sent the Same Prompt to Four AIs and Saw an Answer That One Alone Couldn't See — SRP Practice Record (February 2026) — A story about observing consensus and branching from four instances of the same model on a "Grothendieck Prime-likeness" task.

---

Conclusion

Many people are already "sending the same prompt to multiple AIs to compare."

SRP gave it a name, formalized it as a methodology, and this time, turned it into a tool.

With a name, we can discuss it. With a tool, we can reproduce it.

If you notice anything while using it, please let me know in the comments. SRP is not a completed method that says "this is how it should be," but a framework for sharing "it was interesting when I did it this way."