Operating principles

How we work

Operating principles for working with CODE AT IT.

The first PR is at-risk

If we don't ship a PR you merge, you don't pay. We absorb the engineering cost. One ticket, one chance, no procurement gymnastics.

When you start with CODE AT IT, the first ticket is on us. You file it, we turn it into a brief, ship a reviewed pull request against your repo, and only invoice when the PR's commit SHA shows up in your default branch. The window is 14 days from PR open. If you don't merge — for any reason — there is no invoice, no chargeback, no negotiation. We absorb the engineering cost. We treat it as our discovery cost, not yours.

The fine print is short. The at-risk PR is capped at about 300 lines of hand-written code, in a single repo, in a stack we support. You give us repo access and one named technical reviewer authorized to merge; we give you a brief, a PR, a diff, and a tested change. Once the first PR merges, every ticket after it is billed normally on merge. Some procurement-locked clients prefer to pre-pay; in that case, the same policy applies as a full refund instead of a deferred invoice. The full operational definition — what “merged” means, scope caps, eligibility, dispute path — is below.

Canonical reference

Operational definition

Canonical reference for the at-risk first-PR policy above. Linkable from MSAs, sales decks, and outreach.

1. The claim, exactly

The first ticket you give CODE AT IT is at-risk. We turn it into a brief, ship a reviewed pull request against your repo, and only invoice if you merge that PR to your default branch within 14 days of opening it. If the PR doesn't get merged — for any reason — you owe us nothing. We absorb the engineering cost. This applies to the first PR of your first engagement with us, scoped at ~300 lines of hand-written code. We treat it as our discovery cost: we'd rather eat a Tuesday than ask you to pay for a PR you didn't ship.

2. Operating definitions

2.1 What counts as “merged”

The agent's PR commit SHA appears in your default branch (main on GitHub/GitLab, configurable on Bitbucket/self-hosted) of the repo named in the kickoff brief, within 14 calendar days of PR open. We use the git host's API as source of truth — if the SHA is in the default branch, it's merged. If it isn't, it isn't.

Edge cases:

Client opens the PR but stalls (no merge, no decision, no feedback) for 14 days → PR auto-closed, no invoice is issued. Same outcome as “didn't merge.” Client owes nothing.
Squash, rebase, or alternate merge strategy that rewrites the SHA → still counts as merged so long as the resulting commit is attributable to the agent's PR (host API marks the PR merged: true).
Merged to a non-default branch, fork, or sandbox repo → does not count as merged for invoicing.
Fraud carve-out: if there's evidence the code was used commercially (deployed to production, shipped in a customer-visible release) without merging to the default branch, the merge condition is satisfied retroactively. We don't expect to use this clause; it lives in the MSA for legal cover, not in the public copy.

2.2 What counts as “we don't pay”

Two operating modes:

Default — deferred invoicing. We issue no invoice for the first PR until merge. No merge → no invoice. Maps cleanly to the marketing claim.
Pre-pay — full refund. For clients whose procurement requires payment before work begins, the first-ticket price is fully refunded if the PR is not merged. Refund issued within 14 calendar days of a valid claim. Refund is the full ticket price as quoted in the SOW — not pro-rated.

In both modes, we do not claim back labor cost, agent compute, third-party tooling, or review hours. We eat that.

2.3 Scope cap on the at-risk PR

The first PR is at-risk only if it falls within these caps:

Code size: ≤ 300 lines of hand-written code, net of generated files (DB migrations, lockfiles, codegen output, schema snapshots, vendored deps).
Files touched: ≤ 12 source files outside generated trees.
Repo count: single repo, single default branch.
Review cycles: at most 2 review rounds (initial PR + 1 revision). Beyond that, scope is contested; we pause and re-brief.
Calendar from kickoff: ≤ 5 business days from brief sign-off to first PR open; ≤ 2 business days per review round after that.
Stack: within our published supported-stack list (TypeScript/Node, Python, Go, Rust by default; others by mutual written agreement).

If the ticket you want as your first PR is larger than these caps, we will either (a) slice a ≤ 300-LoC sub-ticket out of it and run that as the at-risk PR, or (b) accept the larger ticket but tell you, in writing, before kickoff that the at-risk policy does not apply to it. Client picks.

2.4 Eligibility gates (preconditions)

For the at-risk policy to apply, the client must meet these preconditions:

Repo access (read + branch-create permissions for our agent operator) provided within 2 business days of MSA sign.
Brief sign-off by a single named technical reviewer with merge authority on the target branch.
CI environment functional. Tests on the default branch pass at kickoff. If CI is broken on arrival, we will (i) fix it in scope, (ii) reschedule kickoff, or (iii) make the CI fix the at-risk first PR — client picks, in writing.
MSA signed. Standard pilot MSA, no procurement carve-outs by default.
Ticket fits scope cap (§2.3).

If we miss a precondition, the policy stays in force in client's favor. If the client misses a precondition, we waive once on first request and reset the clock; subsequent misses void the at-risk policy for that engagement.

3. Dispute path

The merge condition is observable: SHA in default branch or not. The dispute path is therefore narrow.

“Merged but not materially.” Client claims our merge strategy (e.g., squash, rebase, force-push) didn't constitute a real merge. Escalates to client's named technical reviewer + CODE AT IT CEO, by email, within 5 business days of claim. Target written resolution within 5 more business days.
“PR meets brief vs. doesn't.” If the PR is not merged and we believe the brief was satisfied (client stalled rather than rejected) — the policy is still client-favorable. We don't invoice. We don't argue stalled cases. This asymmetry is intentional: it makes most disputes inert.
Unresolved arbitration. If a case is still open 30 days after the initial claim, we move to third-party arbitration: each side nominates a senior engineer; the two nominees pick a third; the third reads brief + PR + review comments + merge state and judges. Decision is final and binding. Arbitrator fee split 50/50, each side capped at the ticket price.

In practice, the asymmetric “we don't argue stalled cases” rule does ~95% of the work. Arbitration is contract cover.

Arbiter (default): the third-party engineer described above. We do not appoint an in-house arbiter.

4. Timeframe

Money-back claim (pre-pay mode only): must be filed within 30 calendar days of PR close. PR close = formally closed without merge, or no merge after 14 days of open. After 30 days, claim window expires.
Refund issuance (pre-pay mode): within 14 calendar days of a valid, undisputed claim.
Deferred invoicing (default mode): no claim window applies — if the PR doesn't merge, we simply don't invoice.

5. Limits on use

Once per client. Applies to the first PR of the first engagement between the client (legal entity) and CODE AT IT.
Does not stack. Cannot combine with promotional discounts, referral credits, or trial offers.
Does not apply to subsequent tickets. Tickets 2+ are billed normally on merge per published per-ticket pricing.
Strategic accounts (initial pilot scope > $10K) excluded by default. Strategic-account pilots are negotiated in the MSA; the at-risk policy may or may not apply, in writing, deal-by-deal.
Non-transferable. Cannot be assigned to a different legal entity, subsidiary, or partner.