Which LLM is best at prompt engineering?

The Real Answer: There Is No Single 'Best' LLM for Prompting

You've compared spec sheets, watched model demos, and read the benchmark hype — yet your prompts still produce inconsistent output. The uncomfortable truth from the research: the question "which LLM is best at prompting?" has no single answer, and chasing one may be costing you more than it returns.

Every credible source converges on the same conclusion: model choice is task-dependent. As one LLM selection guide puts it, "the honest answer to 'which LLM should I use' is not which model is best, but which model is best for what." The market has moved from single-model dominance to multi-model ecosystems, where selection depends on code quality, latency, context length, and cost constraints.

Here's the finding that reframes the whole debate: well-crafted prompts with a mid-tier model frequently outperform poorly prompted frontier models. That means the higher-leverage decision isn't which brand you pick — it's how well you define the task. "Effective task definition often matters more than model selection," the same guide notes.

The data backs this up. A Princeton/Google DeepMind study cited in prompt-engineering research found tree-of-thought prompting hit a 74% success rate on the Game of 24 benchmark — versus 49% for chain-of-thought and just 33% for standard prompting. Same models, radically different results, purely from technique.

Benchmark gaps are also narrower than marketing suggests. Models scoring within 2–3% of each other on MMLU are "functionally indistinguishable on that metric," and benchmark analysts warn that benchmarks rarely reflect your application's specifics. So before upgrading models, invest in prompt quality:

• Run identical prompts across models, as a Berkeley controlled test did — all three major models caught the same embedded data issue, differing mainly in style, not capability.
• Use meta-prompting: a more capable model can optimize prompts for a less capable one, so your "best prompting LLM" may not be the one executing the work.
• Cache system prompts and frequently-used instructions — Claude's 90% cached-input discount dramatically cuts repetitive workflow costs.
• Remember that a "cheap" model requiring constant fixes costs more than a premium model that works correctly.

Prompt quality, not model brand, is the decision that compounds. This is also why reusable instruction packages — agent skills — are gaining traction: they're prompt engineering done once and shared. SkillzBench is building a free directory and MCP connector to discover, verify, and benchmark those skills, since research found roughly 26% of published skills carry at least one vulnerability. Test before you trust — whether it's a model or a skill.

What the Evidence Says: Claude's Adherence Edge vs. ChatGPT and Gemini's Strengths

Ask three models the exact same question and you may get three very different answers — which is precisely what researchers did when testing how today's leading LLMs handle prompts. The results reveal distinct strengths rather than a single winner.

The most direct evidence on prompt-following comes from hands-on testing. When given a complex prompt with specific formatting requirements, numbered constraints, and edge cases, 30 days of side-by-side testing found that Claude honors all of them, while other models sometimes drop requirements from long prompts. The same review noted Claude is notably good at using information it receives rather than losing track of earlier conversation parts — though it's worth flagging that this was a single-reviewer, anecdotal test, not a controlled benchmark.

A more rigorous comparison came from a controlled identical-prompt test run by UC Berkeley's School of Information. All three models caught a deliberately embedded data quality issue, meaning the differentiation was in style and depth, not raw capability:

• ChatGPT produced the most structured, documentation-ready output
• Gemini was the most technically precise — and the only model to infer a pandas type-coercion risk unprompted
• Claude was the most interpretive and reasoning-forward

Because prompt engineering is largely about instruction-following, proxy benchmarks fill the gap where direct tests don't exist. IFEval, which measures adherence to verifiable constraints, is considered the closest proxy for prompt-following ability — though no head-to-head scores were available in the sources reviewed. On Terminal-bench, which tests agentic CLI work, Claude Opus 4.5 led at 59.3%, ahead of GPT-5.2 at 47.6% and Gemini 3 Pro at 42.1%.

Two caveats deserve equal weight. First, no source directly benchmarks models on writing prompts — the core question is answered only through proxies, and the meta-prompting insight that "you use a more capable model to optimize prompts for a less capable one" confirms models differ in this ability without ranking them. Second, benchmark scores within 2–3% are functionally indistinguishable, and sources themselves conflict on reasoning leaders.

This matters for anyone building with agent skills, which are essentially prompt engineering captured as reusable instruction packages. SkillzBench is building a free directory and benchmarking infrastructure that tests skills in a sandbox with the same model, with and without the skill, so you can see each one's Lift rather than trusting marketing claims — the same evidence-first mindset this comparison demands.

The practical takeaway: match the model to the task. Claude for constraint-heavy, adherence-critical work; ChatGPT for structured deliverables; Gemini for technical precision. Then verify with your own identical-prompt tests, because benchmarks test general capability, not your edge cases.

Why Benchmark Scores Won't Settle This (and What Actually Will)

If you've been refreshing LLM leaderboards waiting for a definitive answer, you're asking the wrong question. The data suggests benchmarks can't settle this debate — and relying on them may actively mislead you.

Start with the numbers themselves. Selection guidance is blunt: models scoring within 2–3% of each other are "functionally indistinguishable" on that metric. Most of the headline gaps between frontier models fall inside that margin — which means the "winner" often depends on which leaderboard you opened that morning.

The conflicts are real, not hypothetical. SWE-bench Verified figures for the same models vary wildly across sources: one comparison guide reports Claude Opus 4.5 at 80.9% and GPT-5.2 at 80.0%, while another source cites Claude at 80.84% and ChatGPT near 74.9%. Reasoning leadership flips entirely depending on the source — GPT-5.2 tops GPQA Diamond in one roundup; Gemini 3.1 Pro leads it in another. Contamination compounds the problem: OpenAI has flagged training-data contamination on SWE-bench Verified across all frontier models, and coding scores "depend heavily on the agentic scaffold" rather than raw model ability.

What actually works: run your own head-to-head test. The Berkeley I School's controlled experiment did exactly this — identical prompts, same dataset, all three models. Every model caught the embedded data quality issue; differentiation came down to style (ChatGPT most structured, Gemini most technically precise, Claude most reasoning-forward). Your use case, not a leaderboard, is the real differentiator.

When you run that test, fold in the economics:

• Cost — Claude's cached input runs $0.50/M tokens, a 90% discount, so cache system prompts and repeated instructions.
• Speed — GPT-5.2 generates at 187 tokens per second, roughly 3.8x faster than Claude.
• Context — Gemini 3 Pro offers a 1M-token window at $2.00/M input, ideal for long-context prompting work.
• Volume — DeepSeek V3.2 costs roughly 94% less than Claude, worth testing for high-volume prompt iteration.

Remember that prompt quality itself can outweigh model choice — well-crafted prompts with mid-tier models frequently beat poorly prompted frontier models. That's why SkillzBench is building a free directory and MCP connector for agent skills: pre-written, security-scanned SKILL.md instruction packages are essentially prompt engineering done once and reused, and with published research finding roughly 26% of skills carry at least one vulnerability, validated instructions matter as much as model choice.

A "cheap" model requiring constant fixes costs more than a premium model that works correctly. Your own tasks, your own prompts, your own economics — that's the only benchmark that counts.

A Practical Prompt-Engineering Workflow: Meta-Prompting and Technique Choices

Knowing which model writes the best prompts matters less than having a repeatable workflow for writing them. The research points to a practical pattern: stop hunting for a single "best" LLM and start pairing models deliberately, choosing techniques by return on investment, and structuring prompts so they survive production.

Start with meta-prompting. As DigitalOcean's practitioner guide puts it, "you use a more capable model to optimize prompts for a less capable one." A frontier model drafts, critiques, and refines the prompt; a cheaper working model runs it at scale. This works because, as one selection guide notes, "well-crafted prompts with a mid-tier model frequently outperform poorly prompted frontier models."

Next, choose techniques by ROI, not novelty. The evidence is concrete: on the Game of 24 benchmark, tree-of-thought prompting hit a 74% success rate versus 49% for chain-of-thought and 33% for standard prompting — but at $0.74 per case versus $0.13 for the baseline, per the same guide. That is a real lift, and a real cost. Reserve heavy techniques for high-stakes tasks; simple, structured prompts handle the rest.

A few practices carry outsized weight for the effort involved:

• Skip heavy-handed role prompting. Assigning a persona identity "may actually backfire by limiting helpfulness" — specify the perspective you want instead.
• Explicitly permit "I don't know." Giving a model permission to admit uncertainty measurably reduces hallucination.
• Cache structured system prompts. Cached input runs at a 90% discount on Claude pricing, which "reduces repetitive workflow costs dramatically" per pricing analysis.
• Accept trade-offs consciously: prompt chaining "trades speed for accuracy," and reflection adds latency but often improves quality.

Structured inputs like JSON improve accuracy across models, according to IBM's guidance — another reason to keep system prompts stable and cacheable rather than rewriting them per request.

If you build agent workflows, this logic extends beyond prompts you write yourself. Agent skills are essentially prompt engineering done once and reused — and since published research found roughly 26% carry at least one vulnerability, validated packages beat copy-paste from random repos. SkillzBench is building a free directory and MCP connector that will let you discover, security-scan, and benchmark skills in a sandbox, so the prompt layer of your stack gets the same rigor as the model layer.

The takeaway: your workflow — meta-prompting, ROI-driven technique selection, honest uncertainty, caching — determines outcomes more than any single model choice.

From Prompt Engineering to Agent Skills: Stop Rewriting the Same Prompts

If you find yourself rewriting the same instructions for the hundredth time, you're not doing prompt engineering — you're doing prompt maintenance. The field itself is moving on: IBM now frames prompt work as shifting toward context engineering, where you shape what the model sees once and reuse it everywhere.

That's exactly what agent skills are. A skill is a SKILL.md instruction package — a prompt engineered once, validated, and loaded automatically by tools like Claude Code, Codex, Cursor, and Gemini CLI. Instead of pasting your best prompt into every session, you package it and let any agent use it.

The economics favor this shift. Selection research notes that effective task definition often matters more than model choice, and industry analysis lists prompt-engineering effort as a real total-cost-of-ownership factor. Done once and reused, a skill converts recurring prompt labor into a one-time investment.

The catch: reuse amplifies both good and bad. Published research found that roughly 26% of agent skills carry at least one vulnerability — a prompt that quietly injects instructions or leaks context is now baked into every task that loads it. Reusing an unverified prompt is worse than retyping a mediocre one.

So before you adopt any skill, treat it the way you'd treat a model:

• Pin the exact version — you need to know precisely what instructions your agent is running
• Security-scan the skill for injection and data-exposure risks before it touches real work
• Check the license — a skill you can't legally use in production is a liability
• Test it both ways: same task, same model, with and without the skill

That last point mirrors the advice throughout this article. Just as controlled identical-prompt testing is the only honest way to compare models, a with-and-without test is the only honest way to judge a skill. If output quality doesn't measurably improve, the skill isn't helping — it's adding attack surface.

This is the problem SkillzBench is being built to solve. Its free, pre-launch directory will continuously crawl and dedupe skills from GitHub, pin every version to a commit SHA, and run security scans and license checks on each one. Its benchmarking pipeline will test every skill in a sandbox with the same model, with and without the skill, and publish the Lift in percentage points — so you can see what a skill actually contributes, separately from any rating.

A free MCP connector will tie it together: you toggle skills and tools per agent, and the agent only sees what you've chosen. Track upstream changes, re-scans, and re-benchmarks keep loadouts current as skills evolve. The result is prompt engineering you do once, verify once, and trust everywhere — skills, proven, instead of prompts rewritten on faith.