The contract clause that almost cost me my entire codebase

I almost signed it.

The project looked good. The client seemed reasonable. The money was fair. I'd been freelancing long enough to know the drill get the contract, skim it, sign it, start working.

This time, for no particular reason, I actually read it.

Buried in section 4 or maybe section 6, I don't remember exactly was a line that stopped me cold. Something about "pre-existing materials." Standard boilerplate, right? Except it wasn't.

The clause said that anything I brought into the project including tools, libraries, and code I'd written before the engagement would become the exclusive property of the client upon completion.

Let that sink in.

Every utility function I'd spent years refining. Every internal library I reused across client projects. Every tool I'd built for my own workflow. All of it. Theirs. The moment I delivered the project.

What "pre-existing materials" actually means

Most freelance contracts have an IP assignment clause. That's normal the client pays you to build something, they own what you built. Fair enough.

But "pre-existing materials" is different. It's the stuff you owned before you ever heard of this client. Your code. Your tools. Your background IP.

A well-written contract carves this out explicitly. Something like: "Contractor retains ownership of all pre-existing materials. Client receives a license to use them as incorporated into the deliverables."

A badly written or deliberately predatory contract does the opposite. It lumps everything together under one broad assignment clause and hopes you don't notice.

I noticed.

What I did

I pushed back. Told the client the clause needed to be amended before I could sign.

The response surprised me. They got defensive. Not "oh that's just boilerplate, of course we'll fix it" defensive. Like I'd caught them doing something they knew was wrong.

That told me everything I needed to know. I walked away from the project.

What to look for in any freelance contract

If you take nothing else from this, scan every contract you sign for these:

1. Pre-existing materials / background IP

Any clause that assigns ownership of things you brought to the project, not just what you built for it. Red flag if there's no

explicit carve-out retaining your ownership.

2. Perpetual non-competes

"During and after the term of this agreement" with no time limit. This means forever. A reasonable non-compete has a duration — 6 or 12 months. No duration means no end.

3. Unlimited liability

If something goes wrong — a bug, a security issue, anything — are you personally on the hook with no cap? Some contracts make you liable for damages that could exceed what you were even paid.

4. Payment at sole discretion

"Client may withhold payment for deliverables deemed unsatisfactory at Client's sole discretion." Translation: they can refuse to pay for any reason and you have no recourse.

5. Work for hire with no exceptions

Everything you create during the engagement becomes theirs. Fine for the deliverables. Not fine if it includes general tools, open source contributions, or personal projects you worked on simultaneously.

What a safe version looks like

Here's the rewrite I proposed for the pre-existing materials clause:

"Contractor retains all ownership of pre-existing materials, tools, and background technology used in the project. Client receives a perpetual, non-exclusive, royalty-free license to use such materials solely as incorporated into the deliverables. All intellectual property developed specifically for this project shall be owned by Client upon receipt of full payment."

That's it. Both parties are protected. Client gets what they paid for. You keep what you built before they ever hired you.

Most reasonable clients will accept this without argument. The ones who don't are telling you something important about how the rest of the engagement will go.

Why I built Clause

After this happened I started paying more attention to contracts. Talked to other freelancers. Turns out this isn't rare it's common.

Clients use broad boilerplate and count on developers being too busy, too eager, or too intimidated to read it carefully.

So I built a tool that does the reading for you.

Paste any contract into Clause and it flags the dangerous clauses explains what each one means in plain English, why it's risky, and suggests a fairer rewrite you can send back to the client.

It's free to use and doesn't require an account to try.

Clauseapp.space

If you've ever been burned by a contract clause or nearly missed on I'd genuinely like to hear about it in the comments.