first-client-contract

name

first-client-contract

description

Put your first client agreement in writing — the eight clauses a simple service contract must have, in plain language a non-lawyer can use, with the blanks filled from your actual deal. Use when asked write my first client contract, what should a freelance agreement include, my client wants to start without a contract, or review this simple services agreement. Produces the plain-language agreement draft with the eight load-bearing clauses, the per-clause reasoning, the how-to-send-it script, and the when-this-needs-a-lawyer triggers.

First Client Contract Skill

The first client contract's job isn't winning lawsuits — it's preventing misunderstandings between honest people, which is 95% of what goes wrong. A one-page plain-language agreement covering eight things (who, what, when, how much, what's extra, who owns what, how either side exits, what happens late) beats both alternatives: the handshake (where scope and payment live in two different memories) and the 30-page template (which nobody reads, including its sender). This skill drafts that page from the actual deal — and names plainly when the stakes have outgrown it.

What This Skill Produces

• The agreement draft — one to two pages, plain language, the eight clauses filled from the real deal
• The per-clause reasoning — why each exists, told through the failure it prevents
• The send script — how to introduce a contract without making it weird ("this just makes sure we're aligned")
• The lawyer triggers — the situations where this simple form stops being enough, listed honestly

Required Inputs

Ask for these if not provided:

• The deal — what's being delivered, by when, for how much, paid how (the draft is only as real as these)
• The scope edges — revisions included? Meetings? Support after delivery? The extras that will otherwise be argued about later get written now (chain: scope-creep-response is cheaper to never need)
• The work's nature — creative work makes the IP clause load-bearing; ongoing work makes termination load-bearing; the draft weights accordingly
• Jurisdiction, loosely — a governing-law line and any local formality get flagged verify-locally; the skill drafts structure, not local law

Framework: The Eight Clauses

1. Parties & scope (the misunderstanding killer): who, and specifically what — deliverables enumerated, not described by vibe ("a website" vs. "a 5-page site: home, about, services, blog, contact — content provided by client"). The scope clause prevents more disputes than the other seven combined.
2. Timeline with dependencies: dates, and the client's obligations stated ("timeline shifts day-for-day with delays in client content/feedback") — the clause that protects against the client's own lateness becoming your breach.
3. Price and payment terms: the amount, the schedule (deposit % up front — normal and healthy; milestone or on-delivery for the rest), invoice terms (net-X), and the late line (chain: late-invoice-escalation works far better with this clause behind it).
4. What's extra: revisions included (a number), meetings included (a number), and the sentence that handles everything else: "work beyond this scope is quoted separately before it begins." This clause is the scope-creep vaccine.
5. Ownership & credit: who owns the work product and when (standard protective form: on full payment — flagged as a choice), what the freelancer may show in a portfolio, whether background tools/libraries stay the freelancer's.
6. Termination (both directions): either side can exit with N days' notice; work completed to date gets paid; deposits' fate stated. The clause everyone hopes is decorative and occasionally isn't.
7. The reasonable-limits line: liability capped at fees paid, no consequential damages — in plain words, flagged as jurisdiction-sensitive (enforceability varies — verify locally for real stakes).
8. Signatures and the boring details: dates, governing law (verify-locally), and the line that says email counts for approvals — because it's where approvals actually happen.

The lawyer triggers, stated with the draft: deal size that would hurt to lose, IP that's the client's crown jewels, exclusivity/non-compete asks, liability-heavy work, anything cross-border, or a counterparty redlining hard — at those stakes, this draft becomes the brief you bring to a lawyer, which is still a great use of it.

Output Format

Services Agreement: [freelancer] × [client] — [project]

[The draft, 1–2 pages, all eight clauses filled from the real deal, plain language throughout, verify-locally flags inline where local law matters]

Why Each Clause (for you, not the client)

[Per clause: the failure it prevents, in one line]

Sending It

["Attached is a simple agreement so we're fully aligned on scope and terms — nothing exotic, mostly what we discussed written down. Any questions, happy to walk through it."]

When This Isn't Enough

[The lawyer triggers, assessed against this deal — with the honest verdict]

A plain-language agreement between honest parties, not legal advice — enforceability details vary by jurisdiction; past the named triggers, a lawyer reviews (and this draft makes that review fast and cheap).

Quality Checks

• Scope enumerates deliverables — nothing described by vibe
• Revisions and meetings carry numbers; the everything-else-is-quoted sentence appears
• Payment includes deposit, schedule, terms, and the late line
• Ownership states its timing (payment-linked) and the portfolio right
• The lawyer triggers are assessed against this actual deal, not just listed

Anti-Patterns

• Do not draft legalese — plain language honest parties both read beats boilerplate nobody does
• Do not start work on "we'll sort the paperwork later" — the deposit + signature IS the sorting
• Do not leave revisions uncounted — "reasonable revisions" is a fight with a fuse lit
• Do not transfer IP before payment completes without flagging the choice being made
• Do not pretend this scales to every deal — the triggers list is load-bearing honesty