Skip to content
pressfit.ai

Prompts vs BPE

Stop re-prompting a skill that went off the rails. Put the path in code.

Prompts and skill vaults make AI faster to start. They don't make it reliable enough to trust. Here is what our research showed, side by side, and what a Business Process Engine does differently.

The Big 6 skill vault

The Big 6, in a skill vault. Still a prompt.

Skill vaults are everywhere right now: the Big 6 consulting playbook, packaged as Claude skills. Problem framing, issue trees, market sizing, the recommendation deck. Every one of them is useful. Every one of them is still a set of instructions the model reads and interprets its own way.

A vault tells the model what good looks like. It doesn't make the model do it the same way twice, and it doesn't stop a long job from drifting.

Skill
Problem Framing
Skill
Audience Brief
Skill
Research Synthesis
Skill
Source Validation
Skill
Executive Summary
Skill
SCQA Storyline
Skill
Pyramid Structure
Skill
Issue Tree
Skill
Hypothesis Map
Skill
MECE Check
Skill
Market Sizing
Skill
Competitor Benchmark
Skill
SWOT Analysis
Skill
Five Forces
Skill
PESTEL Scan
Skill
Value Chain
Skill
Growth Strategy
Skill
Business Case
Skill
Financial Model
Skill
Scenario Analysis
Skill
Unit Economics
Skill
KPI Dashboard
Skill
Insight Synthesis
Skill
Recommendation Deck
Skill
Implementation Roadmap
Skill
Risk Assessment
Skill
Stakeholder Map
Skill
Pricing Strategy
Skill
Operating Model
Skill
Decision Memo

Where they fall short

Prompts and skills get you started. They don't get you to reliable.

Prompting

  • Same brief, same files, same model: Claude alone gave seven different answers in ten runs.
  • You deliver the model's opinion, not your method. Your client can prompt for that on their own.
  • Spread a task over several turns and performance dropped 39% on average across 200,000+ simulated conversations (Microsoft and Salesforce).
  • Someone experienced has to read every output before it goes out.

Skills and skill vaults

  • A skill is still an instruction. The model reads it a little differently every run, and every team writes its own.
  • The model still decides the process. On a real client job at 300 steps, Claude + skills and hooks got 85% right.
  • Context gets dropped or compressed. A document being available doesn't mean the model uses the right part at the right moment.
  • When a run goes off the rails, the fix is another prompt and another full run.

Side by side

Prompting vs skills vs a Business Process Engine.

Same model, same brief, same files. Prompting is Claude alone, skills are Claude + skills and hooks, and the BPE is Pressfit BPE, as tested by our Red Dev Test team.

PromptingSkillsPressfit BPE
Who decides the stepsYou, one prompt at a timeThe model, reading the skillsCode: LangGraph and Python, server side
Same answer in ten runs, short job7 different answers1 answer1 answer
Correct at 20 steps, real job82.5%95%100%
Correct at 300 steps, real job70%85%97.5%
How output is checkedA person reads itHooks check the formatThe deliverable must pass its tests before delivery
When it goes off the railsRe-prompt and rerunRe-prompt the skill and rerunIt fails the test and doesn't ship. The fix goes into the code once
Token spend1.7M to 5.7M on the same 70-step jobRereads and reruns add up0.56M to 0.63M on the same job

Short job: ten runs per setup. Real job: an equipment rental client's Playbook, run at 20 and 300 steps. Token figures: six runs per setup on a two-hour, 70-step job; we didn't run skills on that one. Read the research.

See the deterministic path run

Code runs the process. The model gets one bounded job.

This is the reference vendor audit graph from our starter kit. The business logic is an explicit graph. Code handles the state, the routing, the retries and the saves. The model is called once, for the one step that needs judgement, and it has to return a typed result. Run a deliverable that passes and one that doesn't, and watch the state change.

Click any step, or run the graph.

↓
↓
↓

Passes

Below the bar

State is saved after every step (Postgres or Redis)

Step inspectoringest_data_node

Sanitize the data and set the state

Plain Python cleans the inputs and sets the starting state. Data prep runs in code, so it costs no tokens and the format never drifts.

Type
Code
Tokens
0
Determinism
100%

Typed WorkflowState

{
  "vendor_id": "VEND-9921",
  "vendor_docs": [
    "Tax Form W9 Verified",
    "Certificate of Insurance Active"
  ],
  "compliance_passed": false,
  "audit_score": 0,
  "retry_count": 0,
  "final_report": ""
}

An example run. Token and timing figures are illustrative.

Tokens by step role

Most steps need no generated tokens once they are written as code.

05001,0001,5002,0002,500Tokens per step0650Schemavalidation01,200Dataingestion4202,400Boundedmodel audit0950Coderouter01,450ReportgeneratorDeterministic graph engineUnconstrained prompt agent

Context size across the workflow

Typed state stays flat. An unconstrained chat history keeps growing with every step.

050100150200250300350Context size (KB)4.52874.51623404.25.15.45.55.8Step 1IngestStep 10AuditStep 25EnrichmentStep 50ValidationStep 100FinalizeGraph engine typed stateUnconstrained chat history

Illustrative figures from the reference architecture, not measured test results. The measured results are in the side-by-side above.

Typed state, not chat history

Never pass raw message threads between steps. Define the state as a typed schema, and pin business rules like approval thresholds as read-only values.

Structured output from every model step

Every model step must return validated JSON. If it comes back malformed, a code retry catches it before the graph moves on.

Routing in code, never in a prompt

Never ask a model which step comes next. Scores, flags and thresholds are checked with plain if/else edges in your code.

Save the state at every step

Checkpoint the state to Postgres or Redis on every edge. If an API times out or a person takes two days to approve, the run picks up where it stopped.

Why deterministic output

Reliable is where the efficiency comes from.

The time savings don't come from a faster first draft. They come from not checking every output, not re-prompting a skill that went off the rails and not paying for the same job twice. That only happens when the deliverable comes out the same way every time and has passed its tests before anyone sees it.

Take a workflow where the output must be redone 30% of the time. That is about 1.43 executions for every accepted deliverable. Bring the redo rate down to 5%, and it is about 1.05, roughly 26% fewer executions before you gain any efficiency inside each run.

The redo rates are an illustration, not a result from our test.

Redone 30% of the time

1.43

executions per accepted deliverable

Redone 5% of the time

1.05

executions per accepted deliverable

Get started

Use our starter kit, or sign up with us.

The starter kit has a workflow spec template, acceptance criteria, rules for the graph, a LangGraph skeleton, a prompt that turns your skill into a graph spec, and a test plan.

Rather have us build it? Our dev team and Red Dev Test team will turn your skills into a coded path and write the tests your deliverables must pass. Fill out the form, or email redevteam@pressfit.ai.

Deterministic Agentic

* required

We reply within two working days. No booking, no sales call.