Skip to content

ProofOne feature. Two ways to build it.

What does one feature actually cost to build?

The comparison takes one issue and builds it twice on the same model: once the conventional way, a developer driving Claude Code with subagents, and once by handing it to developerz.ai. No run is published yet. When one is, both receipts land here whatever they say.

We write the code on your own servers, under your own model keys, never on ours. Around it we triage the issue, dispatch it, review the pull request and ship the release.

The protocol is registered before either arm runs. Whatever the result says is what goes on this page.

01The head to head

Two receipts for the same job.

The feature

https://github.com/developerz-ai/wurk/issues/537

The run happens in a public repository we maintain, and not in this product's own codebase.

registration.repodeveloperz-ai/wurk

Not this product's own codebase, so neither arm builds inside the history it is being measured against. We maintain the venue all the same, and the limits below say so. Both arms land in the same public venue and both timelines are readable by anyone.

  • Same repository
  • Same starting commit
  • Same acceptance criteria
  • Same model

Conventional approach

Developer + Claude Code

A developer drives Claude Code with subagents, on the same model as Arm B, and stays at the keyboard throughout.

Model spend

measured at the run

Model provider console. A fresh API key for this arm, used for nothing else.

Not the full cost of delivering this feature

Calendar timenot measured

Will come from GitHub timestamps: issue opened to pull request merged

Human interventionscounted at the run

Public PR timeline. Anyone can recount it.

Labour and servers are not included

Inspect the receiptwhere the figure comes from

Where this figure comes from

Primary instrumentModel provider consolespend.usd

measured at the run

The provider attests this spend, so you do not have to trust our database. This is the figure that counts.

Not applicableSecondary instrumentspend.our_rows_usd

Not applicable

This arm runs on the developer's own machine, under the developer's own key. No row of ours prices it, so there is no dollar figure of ours to be missing.

The gapspend.usd - spend.our_rows_usd

A gap needs two dollar figures, and this arm has one. The protocol's second instrument here is the session transcript's own token counts, which is not a price.

no second instrument

The work itself

Pull request

not opened yetPending

Session transcript

not recorded yet

A person driving an agent does not reproduce run to run. The prompt and the subagent setup are frozen in writing and the whole transcript is published, which narrows it. Neither closes it.

Orchestrated approach

developerz.ai

The issue is filed and the platform takes it from there. Your AI devs write the code on your own servers, under your own keys.

Model spend

measured at the run

Model provider console. A fresh API key for this arm, used for nothing else.

Includes our orchestration tokens. Nothing netted out.

Calendar timenot measured

Will come from GitHub timestamps: issue opened to pull request merged

Human interventionscounted at the run

Public PR timeline. Anyone can recount it.

00Handoff: the issue is filed, then the platform dispatches it. After that we ask a person only where the repository's policy escalates, and security, license and CLA always do.

Your servers and your model keys are billed to you, not by us

Inspect the receiptwhere the figure comes from

Where this figure comes from

Primary instrumentModel provider consolespend.usd

measured at the run

The provider attests this spend, so you do not have to trust our database. This is the figure that counts.

Tokens only, no dollar valueOur own recorded figurespend.our_rows_usd

not recorded yet

No rows exist, because the run has not happened.

The gapspend.usd - spend.our_rows_usd

A gap needs two dollar figures. Ours may have none, so it is published as not computable rather than reconciled away or quietly filled with a zero.

not computable

The work itself

Pull request

not opened yetPending

Session transcript

not recorded yet

Every action in this arm is also written to the append-only audit log, which is hash chained.

Frozen before either arm runsRegistration2026-09-14
The feature and its acceptance criteria
Written so a third party can run them
Starting commit, the same for both arms
43f37a9b97d9e2d29fb930e26724600b7c38dd29
Size class of the target, assigned when the feature is selected
small
Model, identical in both arms
z-ai/glm-5.3
Harness, the one thing the two arms vary
Arm A: claude-code. Arm B: native.
Control arm prompt and subagent setup
Published verbatim
Stopping rules, one pair for both arms: done, and failed
Both written out in full
Public venue, a repository we maintain
developerz-ai/wurk
Reviewer, who reads with authorship hidden
Din (developerz.ai)
What we expect, written before either arm runs
Nine falsifiable predictions across money, time and people, scored against the records when they land: github.com/developerz-ai/wurk/issues/530
The public record, in posting order
Every amendment, skip and status note, dated and unedited, on the registration thread: https://github.com/developerz-ai/wurk/issues/530

These were written down first, in a public issue. GitHub exposes issue edit history, so you can check they were not rewritten after the numbers arrived.

02The prediction

What we expect, before the answer exists.

A page that shows its numbers only afterwards asks you to believe those numbers surprised nobody. So here is what we expect, published on the registration before either arm runs and scored against the records when they land. Nothing below is a measurement. Each line says its commitment in plain words, and the same line below the three groups names the record field it will be judged on, so it can be marked right or wrong without anyone exercising taste. It is protected against knowing the outcome and not against knowing the task, which is limit 9 and the reason it is called a prediction and never a pre-registration.

  • Model spend

    Anchored on this product's own repository, where a merged pull request records 17.7M input tokens and a floor of $3.97, a floor because about 26% of those tokens carry no dollar value at all.

    1. 01

      developerz.ai spends more on the model than the developer with Claude Code.

    2. 02

      developerz.ai's model spend shows no dollar figure, so its receipt makes no money comparison.

    3. 03

      If the model spend shows no dollar figure, developerz.ai still uses more input tokens than the developer with Claude Code.

  • Calendar time

    Anchored on the one prior cycle this venue has run: 8 minutes 47 seconds from issue open to bot pull request, and 37 minutes 10 seconds to merge, on a three line configuration change rather than on Ruby a consumer runs.

    1. 01

      developerz.ai goes from an opened issue to a merged pull request faster than the developer with Claude Code.

    2. 02

      developerz.ai takes under 6 hours from an opened issue to a merge.

    3. 03

      Both sides merge within the 24-hour time limit, so neither is published as a failure.

  • Human interventions

    Anchored on the prior venue pull request, which carried no non-bot actor at all, against a fleet where 563 of 649 pull requests merged in 14 days carry at least one.

    1. 01

      People step in on developerz.ai's pull request no more often than on the one from the developer with Claude Code. Each person counts once per kind: a comment, review, merge or close, the developer's own included.

    2. 02

      People step in on developerz.ai's pull request once at most.

    3. 03

      If the two pull requests differ in how often people step in, they differ by 2 at most.

The record field each line is scored on
  • Model spend

    1. 01

      Arm B spends more than Arm A: spend.usd on the platform record reads higher than spend.usd on the control record.

    2. 02

      The dollar cells publish null for Arm B, so the receipt claims no money comparison at all.

    3. 03

      When the dollar cells read null, Arm B tokens_in still exceeds Arm A tokens_in.

  • Calendar time

    1. 01

      Arm B clock is shorter than Arm A: clock.pr_merged_at minus clock.issue_opened_at reads smaller on the platform record.

    2. 02

      Arm B clock reads under 6 hours, issue open to merge.

    3. 03

      Both arms merge inside the 24 hour stopping rule, so neither record publishes as a failure.

  • Human interventions

    1. 01

      Arm B records no more human touches than Arm A: human_touches reads less than or equal on the platform record.

    2. 02

      Arm B human_touches reads 0 or 1.

    3. 03

      If the two counts differ, they differ by at most 2.

How this is scored

Each line reads right, wrong or unscorable the moment both records land, one line each, off the record fields themselves so no part of the scoring depends on prose. No protocol rule locks these after the fact: rule 6 forbids re-rolling the feature, not re-writing a prediction, so the protection is publication itself. These nine and their scoring rules are dated public comments on an issue whose edit history is open, posted before any record exists, and a revision shows up there as a revision. A prediction that misses stays on this page beside the record that breaks it. One thing it leaves alone on purpose is which pull request the reviewer prefers, because that is the single judgement here with no instrument behind it.

Read the predictions as published, in posting order

03Result

No result. No conclusion.

The comparison has not run. The protocol is registered first, then both arms run, then this panel fills in whatever it says. Until then nothing on this page is a measurement.

model spend

Not measured

no figure yet

Model provider console, one fresh key per arm

calendar time

Not measured

no figure yet

GitHub timestamps, issue opened to merge

human interventions

Not measured

no figure yet

Public PR timeline, recountable by anyone

n = 0 published comparisons. No run has been recorded, so these three cells have no sample behind them. The design tops out at one run per arm, which would not support a significance claim either.

One feature, built two ways. It is a demonstration with receipts, never a rate. Arm B includes our own orchestration tokens: you pay for those under your own keys, so they are not netted out.

Read the method

04The human verdict

One reader. Both pull requests. Names hidden.

A named reviewer reads both pull requests in one sitting, with branch names and commit authorship stripped. He is also the one driving the control arm, so he recognises his own diff: that is all the word blind means here. It stays prose. There is no score, no rating and no bar, because we have no publishable number for review quality and inventing one would be fabrication.

Reviewer

Din (developerz.ai)

The protocol names the reviewer before the review, and authorship stays hidden until the verdict is written.

ADeveloper + Claude Code

no verdict yet

Bdeveloperz.ai

no verdict yet

Which one would you merge?

This answer is allowed to be neither, or no preference.

unanswered

05At your volume

Your bill does not move per feature.

It moves when you add an AI dev. So the cost of a feature is whatever your monthly subscription divides into, and the more you ship the less each one carries. Here is one worked example, at the Enterprise rate the pricing page publishes.

One worked example

3 AI devs, 8 features shipped in the month.

Enterprise subscription, 3 AI devsEnterprise rate × 3code review and CI included, not extra
$3,000.00
Your servers, 9 enrollable boxes3 AI devs × 3 boxes eachbilled by your host, not by us
your host
Your model keysBYOKbilled to you by your provider
your bill

Per feature, before model spend

$375.00

subscription ÷ 8

The subscription divided by what you shipped that month. Your model spend is billed to you by your provider and is not in it.

This is arithmetic on published prices, not a benchmark result. Your model spend is billed to you by your provider and is not in it.

See the plans on pricing

06Don't take our word for it

Built so you can check.

Quality is not a number we have earned the right to publish. Here are the safeguards you can inspect today.

  • A record that cannot be rewritten without breaking its own chain.

    What this means

    Every action goes into an append-only, hash-chained audit log. Changes leave evidence.

    Inspect the mechanism
  • The checks still have to pass.

    What this means

    CI, review and branch protections gate merges. Orchestration is not permission to skip them.

    Inspect the mechanism
  • A finding needs a source.

    What this means

    Review is cite-or-refuse. A finding that cannot be tied to your code is withheld rather than posted, and the review says how many were. The exception is a rule the bot enforces, which blocks on the rule.

    Inspect the mechanism
  • Your keys, sealed and yours.

    What this means

    Model keys are envelope-encrypted: each key is sealed by its own data key, and that by a master key that never leaves the platform and is never sent to a box. You pay the provider directly and we never resell tokens.

    Inspect the mechanism
  • Your work runs on your servers.

    What this means

    Workers run on infrastructure you control. Connections dial out. No inbound port is needed.

    Inspect the mechanism

07The limits

One feature is not a promise.

Published samplen = 0 published comparisons
Read the limits

One feature built two ways is an anecdote with receipts. That is worth something, and it is worth less than a rate. The published limits are on the page because you would find them out anyway.

  1. 01

    n = 1.

    One feature. A demonstration, never a rate. Unflattering, mixed, or a failure in either arm: it is published as it stands.

  2. 02

    The control is not reproducible.

    One person driving Claude Code varies from one run to the next. We freeze the prompt and the subagent setup in writing and publish the transcript, which narrows it. It does not close it.

  3. 03

    We pick the feature ourselves, and the rule was amended four times.

    Whoever picks the task picks the winner, and the picker here is us. The rule was published before any candidate was listed, and its first application returned an empty set. One clause was then dropped in public, the one excluding issues opened by our own team, and the rule was applied again to eight candidates: every one was skipped for not changing this repository own Ruby. The fallback named in advance was that an outside party files the feature, and no outside party turned out to be available. So the rule was amended once more, in public and before the feature issue existed, to say the team running the study files it. That is what happened. The strongest objection to this comparison, that the task suits our own arm, now has no answer beyond two checks a reader can make: the amendment is posted before the issue exists, and the feature is taken from a gap this repository already documented about itself. The issue body stands unedited and every version of the rule is public in posting order.

  4. 04

    We run both arms.

    The people who built Arm B are the ones driving Arm A, the control we are competing against. An independent run would be worth more than ours, and we would rather say so than imply otherwise.

  5. 05

    Calendar time is not effort.

    Our clock includes queue time you would really wait. The control's clock is one person's uninterrupted attention. That framing flatters the control, not us.

  6. 06

    The reviewer is one of us.

    One reviewer, on our team. He is the one driving the control arm, so he recognises his own diff before he opens either one. Both diffs arrive with branch names and commit authorship stripped, and that is all the word blind means here. An outside reviewer would remove this limit instead of softening it; we do not have one.

  7. 07

    We maintain the venue.

    Both arms run on a public repository we maintain: our org, our CI, our bot on the merge lane. An outside repository would close this limit. What it would take is a maintainer who is not us willing to let both arms open pull requests, run their CI and merge, and we do not have one.

  8. 08

    The frozen model changes twice, then changes back.

    Three dated comments on the pre-registration move it and then restore it. The first two rest on a wrong reading: every account credential for the frozen model is revoked, which is true, and irrelevant, because the coding lane runs on the box's own backend and the venue keeps serving that model throughout. Every version is public and dated before any arm starts, with no result standing against it, so no figure here is one seen first and chosen afterwards. The model stays identical on both sides, so it changes what each one runs and never what tells them apart, and rule 6 still forbids a re-roll. Read the thread in posting order and judge how carefully this was operated for yourself.

  9. 09

    The prediction knows the task, only not the answer.

    We publish what we expect the records to show before either arm runs, so a page that reveals its numbers only afterwards cannot ask you to believe those numbers surprised nobody. It is protected against knowing the outcome. It is not protected against knowing the task, because the selection rule names the feature first, and that asymmetry is the reason this is called a prediction and never a pre-registration. No rule locks the set after the fact: rule 6 forbids re-rolling the feature, not re-writing a prediction, so the protection is publication itself: the predictions and their scoring rules are dated public comments on an issue whose edit history is open, posted before any record exists, and a revision shows up there as a revision. A prediction that lands nowhere near the record stays on the page beside the record that breaks it. One thing it leaves alone on purpose is which pull request the reviewer prefers, since that is the one judgement here with no instrument behind it.

08The method

Written down before we look.

RegisteredThe protocol, as a public issue2026-09-14Public issue, registered before either arm runs, edit history open

What counts as a run.

A run counts as done when the arm opens a pull request on the public venue repository whose diff meets every acceptance criterion on the selected issue, with that repository's own CI green on it, checkable by the reviewer without asking the author anything. An arm that runs out its 24 hour clock without one, or whose driver declares it stuck, is recorded as a failure for that arm, not dropped from this page. This page reads that off the merge, which is the only part of the rule the record carries.

What the figures include, and what they leave out.

  • Money is the provider console total for that arm's own dedicated key. It is not our own rows.
  • Arm B's money includes our own orchestration spend: triage, the scout, the review lane, the babysit driver. None of it is netted out.
  • The clock is GitHub's own, issue opened to pull request merged. One formula for both arms, so both contain CI, review and merge wait. Neither number is hours of work.
  • Every human touch after the pull request opens is counted, in both arms: one per person per kind of touch, and the kinds are comment, review, merge and close.
What the protocol has to fix in advance
  1. 01The feature and its acceptance criteria, written so a third party can run them.
  2. 02The starting commit, the same for both arms.
  3. 03The model, identical in both arms. Two arms on different models are not a comparison.
  4. 04The control arm's prompt and subagent setup, published verbatim.
  5. 05The stopping rules, one pair for both arms: what counts as done, and what counts as failed.
  6. 06The public venue: a repository we maintain, and not this product's own codebase.
  7. 07The named reviewer, who reads both pull requests with authorship hidden.
  8. 08Where each figure comes from: the provider console for money, GitHub timestamps for the clock, the public pull request timeline for interventions.
  9. 09That the result is published whatever it says, and that one feature produces no rate.
The result is published whatever it says.

The protocol is registered as a public issue before either arm runs. If our arm loses, or stops without delivering, that is what goes on this page. GitHub exposes issue edit history, so once the numbers arrive you can check the protocol against it yourself: the body was never edited, and every amendment is its own dated comment.