Skip to content
Learn · vibe coding e-signatures

7 things your AI coding tool gets wrong about e-signatures

Ask Cursor, Claude Code, v0, Lovable, Bolt or Replit for a terms checkbox or a signing page and you get one that works on the first try. These are the seven mistakes those pages share: a pre-checked box, a notice that names nothing, a link to terms that change, a log row you can edit, a notice nobody can see, no copy for the user, and one button doing several jobs. Here is each one as code, why it matters, and the fix.

Why AI-built signing pages share the same mistakes

None of these are bugs. The form submits, the row is written and the page looks finished. They are what a capable tool writes when the only instruction is to add a signup agreement.

The rules for a signing screen are not visible on the screen. Nothing in a rendered checkbox says it has to start unchecked, and nothing in a button says the notice has to name it. They come from the U.S. ESIGN Act, state UETA laws and a line of online-assent decisions in which courts looked at the exact page a user saw. Your tool was not given any of that, so it wrote the shortest thing that works.

The fixes are small. Most are one attribute, one sentence or one extra column. Each section below shows the code a tool writes, the reason it is a problem in plain terms, the corrected code, and how to catch the mistake before a user ever sees it.

  1. Mistake 1 of 7CR-01block

    1. The consent box starts checked

    What the AI tool writes
    <label>
      <input type="checkbox" name="terms" defaultChecked />
      I agree to the Terms of Service
    </label>
    <button type="submit">Create account</button>
    Why it is a problem

    Agreement has to be something the user does. A box that arrives ticked records your default, and submitting the form shows only that the user left it alone. U.S. courts ask for an affirmative act and have refused to treat inaction as assent, as in Nguyen v. Barnes & Noble and Specht v. Netscape. The EU rule pack applies the same rule to a pre-ticked control.

    The fix
    <label htmlFor="agree">
      <input id="agree" type="checkbox" />
      I agree to the Terms of Service
    </label>
    <button type="submit" disabled={!ready}>Create account</button>
    
    // ready is true once ceremony.remainingSteps() holds only "signature.applied".
    // Nothing in your code sets checked or calls .click().
    The rule

    Every checkbox starts unchecked and every typed-name field starts empty. Only the user's own click or keystroke changes them.

    How to catch it

    The SDK records the state of the control when the page loaded (initial_state) and whether a real user event changed it (trusted). In live mode the API refuses to seal a record from a pre-checked box or a scripted click.

  2. Mistake 2 of 7CR-02blockCR-03warn

    2. The notice names neither the documents nor the button

    What the AI tool writes
    <p>By continuing, you agree to our terms.</p>
    <button type="submit">Sign up</button>
    Why it is a problem

    The user has to be told two things before a click counts: what they are agreeing to, and which action means yes. "Our terms" names no document. "By continuing" names no action, and the button says something else. In Berman v. Freedom Financial the Ninth Circuit held that a click shows assent only when the user is explicitly told that it will. Chabolla v. ClassPass turned on button text that did not match the notice, and Godun v. JustAnswer held that a button's own label cannot stand in for that statement.

    The fix
    <label htmlFor="agree">
      <input id="agree" type="checkbox" />
      By checking the box and clicking Create account, you agree to the{" "}
      <a href={`/legal/terms?v=${tos.versionId}`}>Terms of Service</a> and
      acknowledge the{" "}
      <a href={`/legal/privacy?v=${privacy.versionId}`}>Privacy Notice</a>.
    </label>
    <button type="submit">Create account</button>
    The rule

    The notice names every document by its registered title, each one linked, and names the button by its exact label. Never "by continuing" or "by clicking below".

    How to catch it

    The SDK captures the notice text and the button label together. CR-02 lists every document title missing from the notice. CR-03 compares the notice with the label and flags vague phrases.

  3. Mistake 3 of 7CR-08block

    3. The agreement is not bound to an exact version of the document

    What the AI tool writes
    <a href="/terms">Terms of Service</a>
    
    // app/terms/page.tsx renders whatever content/terms.md says today.
    // users.accepted_terms boolean default false
    Why it is a problem

    Terms change. A year from now /terms serves different text, and accepted_terms = true cannot say which text this user was given. The ESIGN Act defines an electronic signature as one "attached to or logically associated with" a record (15 U.S.C. § 7006(5)), so you need to be able to produce that record: the exact words, not the current page. The link also has to work. In an unpublished 2025 memorandum the Ninth Circuit found no mutual assent where the terms link did not open.

    The fix
    // app/legal/terms/page.tsx: render one exact version, by its ID.
    const { v } = await searchParams;
    const { data } = await esc.documents.versions.getContent("doc_8Hq2", v ?? "current");
    
    return (
      <article
        data-esc-document={data.version_id}
        dangerouslySetInnerHTML={{ __html: data.html }}
      />
    );
    
    // In the form, the link carries the version this session pinned.
    <a href={`/legal/terms?v=${tos.versionId}`}>Terms of Service</a>
    The rule

    Register every version through the API and serve it by its version ID. Each record pins the SHA-256 hash of the exact text. Document text never gets pasted into the repository.

    How to catch it

    The SDK hashes the text behind your link and the API compares it with the registered version. A link that serves different text is refused with render_mismatch in live mode.

  4. Mistake 4 of 7fixed by the record, not a page rule

    4. Your own server writes the timestamp and the log row, into a table you can edit

    What the AI tool writes
    await supabase.from("acceptances").insert({
      user_id: user.id,
      accepted: true,
      accepted_at: new Date().toISOString(),
    });
    Why it is a problem

    This row is your own note about your own agreement. Your code wrote it, your clock timed it, and anyone with database access can change it without leaving a mark. That is enough for your app, which only needs to know whether to open the dashboard. It is thin when someone outside your company asks what happened, because the party that benefits from the row is the one that keeps it.

    The fix
    // The browser sends a record ID. Treat it as a claim and check it.
    const { data: record, error } = await esc.records.get(recordId);
    const confirmed =
      !error &&
      ["recorded", "timestamped", "anchored"].includes(record.status) &&
      record.livemode === (process.env.VERCEL_ENV === "production") &&
      record.signer.external_id === user.id;
    // Also compare record.documents[].version_id with the versions your session pinned.
    if (!confirmed) return Response.json({ error: "not_confirmed" }, { status: 409 });
    
    await supabaseAdmin.from("acceptances").insert({
      user_id: user.id,
      accepted_at: record.signed_at, // Esign Comply's server time
      record_id: record.id,          // rec_Z4m8
      receipt: record.receipt,       // signed with keys you do not hold
    });
    The rule

    Keep your table. Write the row only after your server has confirmed the sealed record, and store the record ID and the signed receipt in it. The record itself is hash-chained into an append-only ledger, signed, and timestamped by an outside RFC 3161 authority.

    How to catch it

    No measurement of the page finds this one, because the page looks the same either way. The conformance check tests your server instead: run it with --callback and it posts a forged success to your endpoint and expects a refusal.

  5. Mistake 5 of 7CR-04blockCR-06warn

    5. The notice and the button are not on screen together, or the notice is tiny grey text

    What the AI tool writes
    <button className="w-full bg-indigo-600 py-3 text-white">
      Create account
    </button>
    
    {/* 600 px of logos and feature bullets */}
    
    <p className="text-[10px] text-gray-400">
      By creating an account you agree to the Terms of Service.
    </p>
    Why it is a problem

    Courts judge the screen the user saw. A notice below the fold is on the page and off the screen, and what fits at 1440 wide falls off a phone. Specht v. Netscape refused terms that sat on a part of the screen the user had to scroll to. Meyer v. Uber enforced a notice that was "spatially and temporally coupled" with the button. Berman turned on tiny gray type, and Cruz v. Tapestry on a small gray notice under a prominent button.

    The fix
    <div id="assent">
      <label htmlFor="agree" className="text-sm text-slate-900">
        <input id="agree" type="checkbox" />
        By checking the box and clicking Create account, you agree to the{" "}
        <a href={termsHref} className="text-blue-600 underline">
          Terms of Service
        </a>
        .
      </label>
      <button type="submit" className="w-full bg-indigo-600 py-3 text-white">
        Create account
      </button>
    </div>
    The rule

    The notice sits directly above the button, in the same container, visible without scrolling at 390 by 844. It is set at body size, never under 12 px, with a contrast ratio of at least 4.5 to 1. Courts describe the problem in words such as "tiny gray font". The pixel and contrast values are the thresholds the rule set measures.

    How to catch it

    The SDK records both positions and the viewport size at the signing act. CR-04 blocks when the notice and the button cannot be seen together and warns when the notice sits below the button. CR-06 reports the smallest font and the lowest contrast it measured.

  6. Mistake 6 of 7CR-14block

    6. The user cannot keep a copy of the terms

    What the AI tool writes
    <dialog open>
      <div className="h-64 select-none overflow-y-scroll">{termsText}</div>
      <button onClick={accept}>I agree</button>
    </dialog>
    Why it is a problem

    The user is agreeing to a document, so they get to keep it. Under UETA § 8(c), a record is not enforceable against the recipient when the sender inhibits their ability to store or print it. Where a law requires a contract in writing, ESIGN § 7001(e) lets the electronic version be denied effect when the parties cannot retain and reproduce it. The EU E-Commerce Directive requires terms to be made available so the customer can store and reproduce them. Under the EU rule pack a receipt emailed afterward does not replace that.

    The fix
    // On the document page, next to the exact version it renders.
    <a data-esc-download href={`/legal/terms/download?v=${data.version_id}`}>
      Download
    </a>
    <button type="button" data-esc-print onClick={() => window.print()}>
      Print
    </button>
    
    <article
      data-esc-document={data.version_id}
      dangerouslySetInnerHTML={{ __html: data.html }}
    />
    The rule

    A download control and a print control for the exact pinned version are offered before the assent control. Nothing blocks selecting, saving or printing the text. The signer gets a copy after signing.

    How to catch it

    The SDK records whether download and print controls were offered before assent. CR-14 runs when an EU, UK or Swiss rule pack applies: it blocks consumer flows without them and warns on the rest. For U.S. flows the generated prompt carries the same rule (US-29), and Esign Comply can email the signer a copy of the record.

  7. Mistake 7 of 7CR-07warn

    7. One button does two things

    What the AI tool writes
    <form onSubmit={signUp}>
      <p>By signing up you agree to the Terms of Service.</p>
      <button type="submit">Create account</button>
      <button type="submit" name="provider" value="google">Continue with Google</button>
      <button type="submit" name="plan" value="pro">Start free trial</button>
    </form>
    Why it is a problem

    One notice sits over three primary buttons. It names one of them at most, so the others take the click with no notice that describes them. The trial button does a second job as well: the same click accepts the terms and starts a plan that renews. In Cullinane v. Uber the First Circuit put it this way: "If everything on the screen is written with conspicuous features, then nothing is conspicuous."

    The fix
    <div id="assent">
      {/* the notice and the unchecked box from mistake 2 */}
      <button type="submit">Create account</button>
    </div>
    
    <div id="social">
      {/* its own notice, and its own session */}
      <button type="button" onClick={continueWithGoogle}>
        Continue with Google
      </button>
    </div>
    The rule

    One primary button inside the assent container. Any other button in it gets type="button". Social sign-in gets its own container, its own notice and its own session. A plan that renews gets its own unchecked consent box beside the renewal terms.

    How to catch it

    The SDK counts the primary buttons inside the assent region and the competing ones in the viewport (CR-07). For sessions with the auto_renewal purpose, CR-10 blocks a record that has no separate renewal consent.

How to catch all seven before you ship

You do not have to stop vibe coding the page or review it line by line. Give the tool the rules up front, then measure what it built. Esign Comply does both, and keeps the record that fixes mistake 4.

  1. 01
    The rules prompt states each rule firstPick your use case, regions, signer types and stack. You get one prompt for Cursor, Claude Code, v0, Lovable, Bolt or Replit that carries the rules for that flow, so the tool starts from an unchecked box and a notice that names the button.
  2. 02
    The SDK measures the pageThe headless browser SDK attaches to the checkbox and button your tool built. It measures the state of the control at load, the notice text, font sizes, contrast and positions, and reports them from the signer's browser.
  3. 03
    The conformance check reports each miss with its fixThe CLI runs your page at three window sizes and prints every finding with the rule ID, the measurement and a plain-language fix. Paste the findings back into your tool. The exit code fails a CI build on a pre-checked box.
Terminal: sample findings for a page with mistakes 1, 2, 5 and 7
$ npx esigncomply@latest check --url http://localhost:3000/signup

Conformance check of http://localhost:3000/signup
Window sizes: 390x844, 768x1024, 1440x900
...

Findings
  BLOCK  CR-01   390x844    The checkbox control was checked when
                            the page loaded.
                              measured: control=checkbox,
                                        initial_state=checked
                              fix:      Render every checkbox unchecked
                                        and every typed-name field empty.
  BLOCK  CR-02   390x844    The notice does not name: Terms of Service.
  BLOCK  CR-04   390x844    The notice and the action control were not
                            in the same viewport at the signing act.
  WARN   CR-03   390x844    The notice uses a vague phrase such as
                            "by clicking below" or "by continuing".
  WARN   CR-06   390x844    Notice text is 10 px with contrast 2.54
                            to 1 (body 16 px).
  WARN   CR-07   390x844    3 primary action controls share the
                            assent region.

Summary: 3 block, 3 warn, 9 pass.

Keep the tool. Add the rules and the record.

Every screen stays yours, and so does the tool you build it with. Two parts come from outside: the rules the signing screen follows, and the record of what happened on it.

One page

A signup clickwrap or a checkout box

Generate a prompt for the flow, paste it into your tool, and run the check on the page it builds. The Free plan includes 10 live signatures a month and a full test mode.

Which pattern to build
A whole product

Your own DocuSign-style app

Upload, field placement, signer links and reminders are yours to build. Every signer link you send runs under the same seven rules.

Build your own signing app
The record

Why it lives outside your database

Mistake 4 has no fix inside your own stack. See what a row in your table shows, what it leaves out, and what a sealed record adds.

How to store terms acceptance

More on the reasoning: why to vibe code the interface and not the record, why a third party keeps it, and the ESIGN Act and UETA checklist for the full list of requirements.

Questions about AI-built signing pages

What do AI coding tools get wrong about e-signatures?

Seven things: a consent box that starts checked, a notice that names neither the documents nor the button, a link to terms with no fixed version, a log row and timestamp written by your own server into a table you can edit, a notice that is off screen or tiny and grey, no copy the user can keep, and several primary buttons under one notice.

Is a pre-checked consent checkbox valid?

A pre-checked box does not show that the user agreed. It records your default, and submitting the form shows only that the user left it alone. U.S. courts look for an affirmative act, and the EU rule pack rejects a pre-ticked control. Render every checkbox unchecked. Esign Comply rule CR-01 refuses to seal a live record from a box that was checked at page load or ticked by a script.

Read rule CR-01

What should the notice next to a signup button say?

Name the action and the documents: "By checking the box and clicking Create account, you agree to the Terms of Service and acknowledge the Privacy Notice." Use the exact label of your button and the registered title of each document, each linked to its exact version. Leave out "by continuing" and "by clicking below".

Clickwrap vs browsewrap vs sign-in wrap

Can Cursor or Claude Code build a signing page that follows the rules?

Yes, when you give it the rules. Pick your use case, regions, signer types and stack in Esign Comply and paste the generated prompt into Cursor, Claude Code, v0, Lovable, Bolt or Replit. The prompt states each rule before the tool writes a line, and the conformance check measures the page it built.

Generate a prompt

How do I check a vibe-coded signing page before going live?

Run npx esigncomply@latest check --url with the address of your page. The CLI opens the page in a headless browser at 390 by 844, 768 by 1024 and 1440 by 900, runs the ceremony with a test signer and prints each finding with the rule ID, the measurement and the fix. It returns an exit code, so it runs in CI.

Read the CLI reference

Give your AI tool the rules before it writes the page.

Free plan: 10 live signatures a month and a full test mode. No card required.

Working with an AI tool? This page is also available as Markdown: /learn/vibe-coded-esignature-mistakes.md