ZAMBO.

Direct answer

Built to their brief. Their brief was wrong. The redo is billable.

The work is delivered, and the client comes back with a discovery: the figures, the name, the specification, the audience, some load bearing fact they supplied at the start was wrong, and now the work built faithfully on it has to be done again. Their framing arrives ready made: the work is not right, so fixing it should be part of the job, meaning free. Your framing has to be built from the record, and it is just as simple: the first build is judged against the information it was built from, and work that matches the brief as supplied was done correctly. A redo caused by corrected information is a second build, with a cause, an owner, and a price. That position, stated early and kindly and backed by the written brief, settles most of these arguments. Here is the sort, the reply, and the intake fix that stops the sequel.

See the instrument first: the live demo runs one real call and hands you its verifiable receipt, no signup.

Updated November 3, 2026. First published November 3, 2026. The two delivery records quoted below are real and public, with their client decision states read back from the live service on November 3, 2026.

Step 1. Put the brief as supplied next to the work before anyone argues

Do not begin with who should pay. Begin with two documents side by side: the information as the client supplied it, in the message, form, document, or call notes both sides hold, and the delivered work. Walk the disputed points one by one and mark each with the only question that matters at this stage: does the work match what was supplied. Where it matches, the work was done as ordered, whatever both sides now wish had been ordered. Where it does not match, that point is a defect, and defects are yours to fix free, and saying so first and plainly is what earns your hearing on everything else. This audit is often shorter than the argument that preceded it, because the wrong information usually sits in one or two load bearing places, a wrong dimension that shaped a layout, a wrong price that shaped an offer, a wrong name spelled consistently and faithfully throughout. Establish the match first. Liability follows the match, in both directions, and a client shown their own supplied figures next to your faithful build rarely keeps arguing that the build was the mistake.

Step 2. Sort every disputed point into defect, input error, or change of mind

Three piles, three owners, no fourth pile. Pile one, defects: the work departs from the supplied information. Yours, fixed free, promptly, without negotiation, and the fix recorded like any other stage. Pile two, input errors: the work matches the supplied information, and the information was wrong. Theirs: the redo is new work, priced in step 4. Pile three, changes of mind wearing an error's clothes: the information was right, the work matches it, and the client simply prefers a different direction now that they can see a finished thing. Also theirs, priced the same way, and named kindly as a change rather than an error, because mislabelling it as an error is how it sneaks into pile one. Write the sort down and send it, points numbered, each with its pile and the supplied wording it rests on. Most redo arguments are really one pile arguing about the rent of another; the written sort ends that by giving every point its own address. A point that genuinely cannot be sorted, where the supplied wording is ambiguous and both readings are honest, split it or absorb it once, and note it as the ambiguity it is, because that pile is the intake lesson in step 6.

Step 3. Read the two states the original build can sit in while the redo is argued

A redo argument is won on whether the original brief and build sit on a record a third reader can check, or inside two memories. The record format is AER-1, published as an IETF Internet-Draft (draft-zambo-aer1-26), and each step carries a verifiable receipt: a receipt proves the saved result was not changed since it was saved. The two public records below show the states a delivery can carry:

Accepted: the decision is on the record

Pending: checked, and still waiting on a decision

An accepted record, 4 of 4 steps checked, decided_by client, release_hint ok_to_release, decided 2026-10-16T14:31:51.146Z in that example, fixes the strongest version of your position: the work, built from the inputs of record, was checked and accepted as delivered, so a redo after acceptance starts from a settled fact that the first job was completed as agreed. A pending record, 5 of 5 steps checked and release_hint hold, is the exposed shape: checked work never decided, into which a wrong information discovery can pour and rewrite the whole job's history. If the original build is still pending when the error surfaces, close the decision on the original build first, against the original brief, and only then open the redo as its own job. Two records, two decisions, no blur: that separation is what keeps a correction from swallowing a completed job.

Step 4. Price the redo as its own stage, sized to the real rebuild

The redo is quoted like any other work, with two refinements that keep it fair and therefore collectable. First, price the rebuild that the correction actually forces, not a fresh performance of the whole job: if the wrong figure touches one section, the redo is that section rebuilt on the corrected figure, plus any knock on work that genuinely depended on it, itemised so the client can see the price follows the blast radius of their error and nothing more. Second, salvage openly: material that survives the correction, research, structure, unaffected sections, is credited in the quote as reused, because a redo quote that visibly reuses everything reusable is very hard to call unfair. State the redo as a named stage with its own price and its own acceptance, started on written agreement to the corrected brief, and delivered against the corrected information exactly as the first build was delivered against the original. If the client balks at the total, the honest middle is scope: redo the load bearing parts now, defer the cosmetic consequences to a later stage, priced separately, rather than discounting the rebuild itself into resentment on both sides.

Step 5. Say it in one message that owns your pile and prices theirs

The reply that settles this has four short movements and no heat. Movement one, the match: I built to the information in your message of the stated date, quoted, and the delivered work matches it at the points listed. Movement two, your pile owned: the points where the work departs from that information, if any, are mine and will be fixed free by a stated date. Movement three, their pile priced: rebuilding on the corrected information is a new stage, quoted at the attached figure, reusing everything that survives, starting on your written go ahead. Movement four, the close: once you confirm the corrected brief, ideally by restating the corrected facts in your reply, I will build to that and the new build will be checked against it the same way. Notice what the message never does: it never calls the client careless, never relitigates how the error happened, and never makes the redo's price sound like a penalty. It is presented as arithmetic, because arithmetic is what it is, and arithmetic is much harder to take offence at than blame.

Step 6. Fix the intake so the next wrong brief is caught before the build

Every input error that reaches a build is also an intake report, and the fixes are cheap. Confirm the brief back in writing before starting: the load bearing facts restated in one short list, figures, names, dates, specifications, with one line asking the client to correct anything wrong, because an error caught at confirmation costs a sentence and the same error caught after delivery costs a redo. For facts the client supplies that everything else depends on, ask for the source, the document, the system, the person who owns the number, and record which source each fact came from, so a later error can be traced to its origin without a memory contest. And carry one sentence in your terms from the start: work built to the information supplied will be rebuilt at the redo rate if that information is corrected after building begins. Clients sign that sentence calmly on day one. Read back to them on redo day, it sounds less like a defence and more like what it is: the rule both sides agreed before either of them needed it.

What a record does not settle

A verifiable receipt proves the saved result was not changed since it was saved; it does not prove the information behind a brief was correct, decide who bears a rebuild cost under a specific contract, or replace advice on a real dispute. The brief as supplied, the delivery record, the acceptance, and your written sort are what the conversation stands on. This page is general information, not legal advice.

Frequently asked questions

My client wants me to redo the work because they gave me the wrong information at the start. Who should pay?

The client pays for the redo, and you pay for any true defects, sorted point by point. The standard is the brief as supplied: where the delivered work departs from the information you were given, that is a defect and you fix it free. Where the work matches the information and the information was wrong, the build was done correctly and rebuilding on the corrected information is new work, priced as its own stage, sized to what the correction actually forces and crediting everything that can be reused. Put the sort in writing, each disputed point with the supplied wording it rests on and its owner, quote the redo as a named stage starting on a written confirmation of the corrected brief, and close the decision on the original build first if it is still open. Most clients, shown their own supplied figures next to a faithful build, accept the arithmetic.

The client says they should not pay because the end result is unusable to them. Are they right?

Usability explains their frustration; it does not move the cost by itself. A build can be faithful and unusable at the same time when the brief it was built to was wrong, and the question is never whether the result works in the world, it is whether the result matches what was ordered from the information supplied. That is why professionals confirm load bearing facts back in writing before building, and why the redo conversation stays on the match rather than on the outcome. There is a fairness limit worth honouring: if the error was obvious on its face, a figure no practitioner could have believed, a name misspelled in a way the client's own materials contradicted, a professional who spotted it, or plainly should have, and built anyway in silence owns a share of the outcome. Outside that narrow case, a hidden error in the client's own information is the client's cost, and the kind move is the staged, salvage credited redo price, not a free rebuild.

What if there is no written brief and the information came over a call?

Then this job is the lesson, and the redo is negotiated from weaker ground, so work it honestly in this order. Reconstruct the supplied information from whatever traces exist, call notes, follow up messages, the build itself, which often reveals exactly what it was built from, and set out your reconstruction in writing as your understanding, inviting correction. Where the client confirms or the traces are clear, the normal sort applies. Where nothing can be established, the practical settlement is usually a shared cost on the redo, agreed as a one off, in exchange for the thing that prevents the sequel: the corrected brief confirmed in writing, in full, before the redo starts. Never start the redo on another unwritten brief to fix a problem caused by an unwritten brief. The second build is where the habit changes, or the third argument is already scheduled.

Should I have checked their information before building on it?

You should check it the way a professional checks any input: for internal consistency, for obvious impossibility, and against any source the client pointed you to. You are not hired to audit the client's own facts back to their origins, and a duty to rebuild free every time a client side fact turns out wrong would make every fixed price a bet on information you do not control. The line that holds in practice is this: errors a competent practitioner would have caught from the material in front of them are on you, and the fix is normally a flag raised before building, which costs the client nothing and you a message. Errors that were invisible in the material, a wrong figure faithfully transcribed from the client's own system, a specification their own team later corrected, are the client's, and are exactly what the brief confirmation step exists to surface early. Raise flags visibly when you see them; a record of raised flags is also, on redo day, a record of diligence.

How do I set up the next job so a wrong brief cannot become a free redo?

Confirm the brief on a record before building, and keep the build on the same record. When the work runs through Zambo, every step carries a verifiable receipt under AER-1, published as IETF Internet-Draft draft-zambo-aer1-26, so the inputs of record, the build steps, and the acceptance sit in one place, and a later correction opens a new, priced stage instead of rewriting the finished one. New users get 20 calls and 1 wrap-up free every day, and picking up work in another AI is always free. For $0.99, run the next brief built job that way and make the redo question a simple read of the record: get the Day Pass. A Day Pass is unlimited for 24 hours, no subscription. Ongoing use is the Zambo Pass at $29 a month or $290 a year, and $19 a month for $ZAMBO holders, which adds private handover links, your branding, and the approval record as PDF and JSON files.

Related