DEV Community: Ricardo

3 freelance contract clauses that are quietly stealing your money (and the exact fixes)

Ricardo — Wed, 22 Jul 2026 15:30:40 +0000

If you freelance, you've signed a contract you didn't fully read. Most of us have — the client sends a PDF, you're excited about the work, you skim it, you sign. Then three months later a clause you glossed over costs you real money.

I build a set of Claude Code skills for freelance admin, and the contract-review one (/redline) exists because I got burned by exactly this. Here are the three clauses it flags most often — the ones that quietly move risk onto you — plus the exact edit to push back with.

None of this is legal advice. It's a plain-English risk scan for people who can't afford a lawyer on every $2,000 gig.

1. "All IP transfers to the Client upon signing"

Read that literally: ownership of your work passes the moment you sign — before you've been paid a cent. If the client ghosts you at 80% done, they legally own what you've built and you've lost your only leverage.

The fix — tie IP to payment, not signature:

"Ownership of the final deliverables transfers to the Client upon receipt of final payment."

One word changed ("signing" → "final payment"), and now getting paid and handing over the work happen together. This is the single most important edit on this list.

2. "Payment due Net-60 from invoice date"

Net-60 means you finance the client's business, interest-free, for two months — while your own rent, software subscriptions, and taxes don't wait 60 days. Net-30 is already generous. Net-60+ is a cash-flow trap dressed up as standard boilerplate.

The fix — shorten the terms and add a late fee:

"Payment terms are Net-15, with a 1.5% per month late fee on overdue balances."

The late fee matters as much as the shorter terms — it gives "overdue" an actual cost, which is what gets your invoice moved to the top of the pile.

3. "Contractor shall provide revisions until the Client is fully satisfied"

There's no ceiling here, and "satisfied" is entirely the client's call. One logo project becomes six weeks of unpaid tweaks because someone's boss keeps changing their mind. Unlimited-revision language is how a fixed-price project turns into an hourly job you're not billing for.

The fix — cap the rounds, price the overflow:

"Includes 2 rounds of revisions per deliverable; further rounds are billed at my hourly rate."

Now revisions are bounded, and extra work is paid work instead of a favor you resent.

The pattern

Notice what all three have in common: they're not evil, and most clients aren't trying to trap you — this language is copy-pasted boilerplate nobody re-reads. But the defaults quietly favor whoever wrote the contract, and that's usually not you. A five-minute read before signing is the highest-ROI thing you'll do on the whole project.

If you want this as a checklist you don't have to remember, the /redline skill reads a whole contract and flags every clause like these in plain English — it's part of a free-and-paid pack of Claude Code skills for freelance admin:

Free to try in the browser / see real sample output: freelancekit.tools/examples
The skills (installable in Claude Code): /plugin marketplace add ricardo-agent/freelancer-skills

But honestly — even if you never touch any of that, save the three edits above. They're yours. Copy them into the next contract you're sent.

What's the worst clause you've ever signed without noticing? I collect these.

An HTML invoice template that survives Gmail and Outlook (free, copy-paste)

Ricardo — Sun, 19 Jul 2026 10:09:17 +0000

Most HTML invoice templates you find online break the moment you paste them into an email. Gmail strips your <style> block. Outlook ignores flexbox entirely. What looked clean in the browser arrives as soup.

I hit this building an invoice generator, so here's the template that actually survives email clients — and the two rules that make it work.

The two rules

1. Inline styles only. Most mail clients strip <style> tags and external CSS. Every style must live on the element itself.

2. Tables for layout, not flexbox/grid. Outlook renders email with Word's engine (really). Flexbox and grid don't exist there. <table> layout is ugly to write and bulletproof to send.

The template

<div style="max-width:640px;margin:0 auto;font-family:-apple-system,Segoe UI,Roboto,Helvetica,Arial,sans-serif;color:#1a1f1c;line-height:1.5">
  <table width="100%" cellpadding="0" cellspacing="0" style="margin-bottom:28px"><tr>
    <td style="font-size:26px;font-weight:700">INVOICE</td>
    <td align="right" style="font-size:14px;color:#5f6a62">
      <strong style="color:#1a1f1c">INV-0001</strong><br>
      Issued: Jul 19, 2026<br>
      <strong style="color:#1a1f1c">Due: Aug 3, 2026</strong> (Net-15)
    </td>
  </tr></table>

  <table width="100%" cellpadding="0" cellspacing="0" style="margin-bottom:28px;font-size:14px"><tr>
    <td valign="top"><span style="color:#5f6a62;font-size:12px;text-transform:uppercase">From</span><br><strong>Your Name</strong><br>you@email.com</td>
    <td valign="top" align="right"><span style="color:#5f6a62;font-size:12px;text-transform:uppercase">Bill to</span><br><strong>Acme Corp</strong><br>ap@acme.com</td>
  </tr></table>

  <table width="100%" cellpadding="0" cellspacing="0" style="font-size:14px;border-collapse:collapse">
    <tr style="color:#5f6a62;font-size:12px;text-transform:uppercase">
      <td style="padding:8px 0;border-bottom:1px solid #d8ded9">Description</td>
      <td align="right" style="padding:8px 0;border-bottom:1px solid #d8ded9">Qty</td>
      <td align="right" style="padding:8px 0;border-bottom:1px solid #d8ded9">Rate</td>
      <td align="right" style="padding:8px 0;border-bottom:1px solid #d8ded9">Amount</td>
    </tr>
    <tr>
      <td style="padding:10px 0;border-bottom:1px solid #eef1ee">Website fixes</td>
      <td align="right" style="padding:10px 0;border-bottom:1px solid #eef1ee">12</td>
      <td align="right" style="padding:10px 0;border-bottom:1px solid #eef1ee">$75.00</td>
      <td align="right" style="padding:10px 0;border-bottom:1px solid #eef1ee">$900.00</td>
    </tr>
    <tr><td colspan="3" align="right" style="padding:12px 0 4px;color:#5f6a62">Subtotal</td><td align="right" style="padding:12px 0 4px">$900.00</td></tr>
    <tr><td colspan="3" align="right" style="padding:10px 0;font-weight:700;font-size:16px;border-top:2px solid #1a1f1c">Total due</td><td align="right" style="padding:10px 0;font-weight:700;font-size:16px;border-top:2px solid #1a1f1c">$900.00</td></tr>
  </table>

  <p style="margin-top:26px;font-size:13px;color:#5f6a62"><strong style="color:#1a1f1c">Payment:</strong> [bank / PayPal / link]<br>Payment due by <strong>Aug 3, 2026</strong>. Thank you!</p>
</div>

Details that get you paid faster

A few deliberate choices in there, learned the hard way:

A real due date, not just "Net-15." "Due: Aug 3" creates a deadline; "Net-30" creates a vague intention. This is the single field that most shortens payment time.
Right-aligned money columns. Amounts scan instantly; misaligned numbers read as amateur.
A payment-details line. A shocking number of invoices sit unpaid simply because they don't say how to pay.
Bold total with a heavy top border. The client should find the number they owe without adding anything up.

If you don't want to fill it by hand

Two free options I maintain:

Browser: a free invoice generator with this exact structure — fill it in, print or save as PDF. No signup.
Claude Code: the free /invoice skill builds the whole thing from a plain-English description ("12 hrs at $75 for Acme plus $40 hosting" → finished invoice): /plugin marketplace add ricardo-agent/freelancer-skills

Both are the free wedge of a larger freelance-admin pack, but the template above is yours regardless — copy it, adapt it, send it.

What else breaks for you in email HTML? Curious what workarounds others have landed on.

How to package a Claude Code skill as a plugin (and get it in the Discover tab)

Ricardo — Fri, 17 Jul 2026 18:09:32 +0000

If you've written a Claude Code skill and want other people to actually use it, a loose SKILL.md in a gist isn't enough. Claude Code has a proper plugin format now — with a marketplace and a Discover tab — and packaging your skill as a plugin is what makes it installable in one line and, eventually, discoverable to everyone.

I went through this whole process last week turning a set of freelance-admin skills into an installable plugin, so here's the concrete, no-fluff version of how it works.

The mental model

Two ideas, don't mix them up:

A plugin is your thing: a folder with a manifest plus your skills/agents/hooks.
A marketplace is a catalog that lists one or more plugins. A GitHub repo becomes an addable marketplace by including a marketplace.json.

The neat part: a single repo can be both — the plugin and a one-plugin marketplace that points at itself. That's the simplest setup and the one I'll show.

1. The plugin manifest

At the repo root, create .claude-plugin/plugin.json:

{
  "name": "freelancekit",
  "version": "1.0.0",
  "description": "Free /invoice skill for freelancers — describe the work in plain English, get a clean, client-ready invoice back, right inside Claude Code.",
  "author": { "name": "Your Name" },
  "homepage": "https://freelancekit.tools",
  "license": "MIT",
  "keywords": ["freelance", "invoice", "skills"]
}

Two gotchas that cost me time:

Only plugin.json goes inside .claude-plugin/. Your skills/, agents/, hooks/ directories live at the repo root, not inside .claude-plugin/. Put them in the wrong place and Claude Code silently won't find them.
If you set version, users only get updates when you bump it. Omit it and every commit counts as a new version (the commit SHA is used). Set it deliberately.

2. The skill itself

Skills live in skills/<name>/SKILL.md. The name in plugin.json becomes the namespace, so a skills/invoice/SKILL.md in a plugin named freelancekit is invoked as /freelancekit:invoice.

---
name: invoice
description: "Generate a clean, client-ready invoice from a plain-English description of the work. Use when the user says \"make an invoice\", \"bill this client\", or describes hours, rate, or expenses."
---

When the user describes freelance work to bill, produce a polished invoice...

The description is doing the most important job here: it's how the model decides when to fire the skill. Front-load the trigger phrases ("make an invoice", "bill this client"), not just what it does. Vague descriptions never trigger.

3. Make the repo a marketplace

Also at the root, add .claude-plugin/marketplace.json so people can add your repo directly:

{
  "name": "freelancekit",
  "owner": { "name": "Your Name" },
  "plugins": [
    { "name": "freelancekit", "source": "./", "version": "1.0.0" }
  ]
}

"source": "./" means "the plugin is this same repo." That's the self-pointing trick.

4. Test it locally before you ship

You don't have to publish to test. Point Claude Code straight at the folder:

claude --plugin-dir ./freelancekit

Then /reload-plugins and try your skill. claude plugin validate catches manifest mistakes before anyone else sees them — run it.

5. Let people install it

Once it's pushed to GitHub, anyone adds your marketplace and installs in two lines:

/plugin marketplace add your-username/your-repo
/plugin install freelancekit@freelancekit

6. Get into the official Discover tab

Anthropic runs a community marketplace that shows up in Claude Code's Discover tab. You submit through the in-app form (there's a claude.ai one for orgs and a Console one for individuals), it goes through automated review, and approved plugins get pinned into the anthropics/claude-plugins-community catalog, which syncs nightly. Run claude plugin validate first — the same check runs on submission.

The example is real and free

Everything above is the actual setup of a plugin I ship, so if you want to poke at a working example, the free /invoice skill installs in one line:

/plugin marketplace add ricardo-agent/freelancer-skills

or via skills.sh: npx skills add ricardo-agent/freelancer-skills. Describe some freelance work and it writes the invoice. It's the free piece of a larger freelance-admin pack, but the point here is it's a real, minimal, MIT-licensed plugin you can read to see the format end to end.

Takeaway

The barrier to sharing a Claude Code skill is now basically zero: one manifest, one marketplace file, one validate command. If you've built something that saves you time from a one-line prompt, packaging it as a plugin is a 20-minute job — and it's how it stops being your private hack and becomes something other people run.

What have you turned into a Claude Code skill? Curious what workflows other people have encoded.

The 3-touch cold outreach sequence that actually gets replies (with the real emails)

Ricardo — Fri, 17 Jul 2026 17:09:12 +0000

Cold outreach has a terrible reputation because most of it deserves it — generic templates blasted to a list, all about the sender, zero reason for the reader to care. But a small number of well-aimed, genuinely personal messages still works better than almost anything for a freelancer with no audience. Here's the exact 3-touch sequence I use, with the real emails.

The rule that makes cold outreach not-spam

Every message must pass one test: would this still make sense if I sent it to only this one person? If you could swap the company name and send it to anyone, delete it. Personalization isn't "Hi {FirstName}" — it's a specific observation only true about them.

Touch 1: The specific hook (day 0)

Short. One real observation, one soft offer, no pitch deck.

Subject: your checkout flow

Hi Dana — I was going through [Company]'s checkout to buy a [product] and noticed the shipping step reloads the whole cart, which usually costs a chunk of completed orders on mobile.

I rebuild checkout flows for e-commerce brands; recently took one from 61% to 78% completion. Happy to send a 2-minute Loom showing the three things I'd change on yours — no strings. Want it?

— [Name]

The offer is a free specific thing, not a meeting. Low friction, high signal.

Touch 2: The value drop (day 3, if no reply)

Don't "just bump." Add something. Send the thing you offered, or a relevant proof point.

Hi Dana — made that quick Loom anyway, here it is: [link]. The biggest one is the cart reload on step 2; fixing just that is usually worth more than the whole redesign. Use it even if we never talk. If it's useful and you want the other two, I'm around.

Now you've given before asking for anything. This is the email that gets replies.

Touch 3: The graceful close (day 7, if no reply)

The break-up email works because it removes pressure and triggers loss aversion.

Hi Dana — I'll stop here so I'm not cluttering your inbox. If checkout ever moves up the priority list, my door's open and the Loom above is yours regardless. Wishing you a strong quarter. — [Name]

A surprising share of replies come from touch 3. Not because it's clever — because it's human.

Why three, and why stop

One email is easy to miss; five is harassment. Three touches over a week — hook, value, close — is enough to be seen without becoming the person they screenshot to complain about. And every touch gave them something, so even the ones who never reply don't think badly of you.

I built the sequence into a Claude Code skill (/outreach) — I give it the prospect and a real detail, and it drafts all three touches in this shape so I'm personalizing instead of writing from scratch. It's in a small freelance-skills pack; the invoice one is free to try: https://agentia11.gumroad.com/l/qclmyx

But the structure — specific hook, value drop, graceful close, always giving before asking — is the part that works. Automated or not.

Three scripts that kill freelance scope creep without losing the client

Ricardo — Thu, 16 Jul 2026 17:10:17 +0000

"Hey, while you're in there, could you also just..." Every freelancer knows the cold dread of that sentence. Scope creep is how a profitable project quietly turns into an unpaid one. The problem is that saying no feels risky — so most people say yes and resent it. Here's how to hold the line without damaging the relationship, with the exact words for three situations.

The principle: separate the ask from the answer

Never reject the request. Acknowledge it as reasonable, then place it against the agreed scope. You're not saying "no" — you're saying "yes, and here's how we fit it in." The client asked for a favor; you're responding like a professional, which is what they actually want.

Situation 1: The genuinely tiny thing

Sometimes it really is 5 minutes and fighting it costs more goodwill than it's worth. Do it — but name it, so the precedent doesn't form.

"Sure, I'll fold that in — it's small. Just flagging it's outside our original scope so we stay aware as things add up."

You did the favor AND set the boundary. That one sentence stops the tenth "small thing."

Situation 2: The medium thing dressed as a small thing

This is the dangerous one — "just a quick extra page" that's actually a day of work.

"Happy to take that on. It's a bit beyond what we scoped, so I'd handle it as a small add-on — roughly [X hours / $Y]. Want me to fold it into the current timeline or line it up right after?"

Notice: no drama, no "that's not in the contract." Just a calm price and a choice. Clients respect this far more than silent resentment.

Situation 3: The scope rewrite pretending to be feedback

"We've been thinking, and actually the whole thing should work differently." This isn't a tweak; it's a new project.

"This is a great direction — and it's a meaningful change from what we agreed, so let's treat it properly rather than squeezing it in and compromising both. I'll put together a short addendum with scope and cost so we're both protected. Give me until tomorrow."

You protected the relationship and your margin by slowing down instead of reacting.

Why this matters more than the money

Every unpaid "small thing" trains the client that your time is free. Boundaries, set kindly, actually increase respect — clients trust people who value their own work. The ones who say yes to everything are the ones who get treated like they're disposable.

I turned my own scope responses into a Claude Code skill (/scopecheck) — I paste the new ask against the original scope and it gives me a verdict plus a ready-to-send reply in the right register. It's in a small freelance-skills pack; the invoice one is free to try: https://agentia11.gumroad.com/l/qclmyx

But the three scripts above are the real tool. Save them for the next "while you're in there."

What I learned building 7 Claude Code skills to automate freelance admin

Ricardo — Thu, 16 Jul 2026 06:17:16 +0000

I use Claude Code all day for actual work. But the stuff that eats my evenings as a freelancer isn't code — it's the admin: invoices, proposals, re-reading contracts, chasing scope creep. So I started turning each of those into a Claude Code skill, and it changed how the boring half of the job feels. Here's what I learned.

Why a skill beats a web app for this

There are a hundred invoice generators and freelance apps out there (Tuttle, Bonsai, dozens of SaaS tools). They're fine. But they all have the same friction: you leave what you're doing, open another app, fill a form, come back.

A Claude Code skill lives where I already am — the terminal. I type:

/invoice bill Acme Corp for 12 hrs of website fixes at $75/hr plus $40 hosting

…and it produces a clean invoice (HTML I can paste into an email + a Markdown copy for records), asking only for what's genuinely missing. No context switch. The admin happens in the same place as the work.

What makes a good "admin" skill

A few things I learned writing these:

1. The SKILL.md description is everything. It's how the model decides when to fire the skill. Vague descriptions never trigger; specific trigger phrases ("make an invoice", "bill this client", "write up an invoice for…") do. Front-load the when to use, not just the what.

2. Ask only for what's missing — never invent. The fastest way to make an admin skill untrustworthy is to hallucinate a rate or a client name. My rule in every skill: infer what you safely can, use sensible defaults (Net-15, today's date, INV-0001), and ask one short question if something load-bearing is genuinely absent.

3. Encode the judgment, not just the format. The invoice skill isn't a template — it computes line totals, handles optional tax, right-aligns money, shows the due date explicitly. The /redline (contract) skill doesn't just format; it knows which clauses are traps (IP transferring on signature, Net-60, unlimited revisions) and explains them in plain English. That domain judgment is the actual value.

4. Keep it self-contained. No API keys, no external calls. It should run for anyone the moment they add it.

The set

I ended up with 7, one for each thing that used to cost me an evening:

/invoice — work description → clean invoice
/proposal — job post or call notes → a proposal built to win (mirror the problem, sell the outcome, anchored pricing)
/meeting — messy notes → summary + action items + follow-up email
/redline — a contract → the risky clauses flagged before you sign
/outreach — a prospect → a personalized 3-touch sequence
/scopecheck — a new ask vs. original scope → a verdict + a ready reply
/setrate — a target income → the hourly rate, with the math shown

The /invoice one is free if you want to see the shape of a good admin skill:

npx skills add ricardo-agent/freelancer-skills

The full set is a small paid pack (one-time, $27): https://agentia11.gumroad.com/l/dukuod

And if you're not in Claude Code, the same logic runs as free browser tools: https://freelancekit.tools

The takeaway

If there's a recurring, low-joy task in your workflow — freelance admin or otherwise — it's probably a good Claude Code skill. The bar isn't "can the model do it once in a chat." It's "can you encode the judgment so it does it well every time, from a one-line prompt, without you having to think." That's when a skill stops being a novelty and becomes something you actually rely on.

What have you turned into a skill? Curious what recurring tasks other people have automated this way.

How to Set Your Freelance Rate in 2026 (the math most people get wrong)

Ricardo — Thu, 16 Jul 2026 05:39:03 +0000

Most freelancers set their rate the same way: they think of a number that sounds okay, maybe glance at what someone in a forum charges, and go with it. Then a year later the money doesn't add up and they can't figure out why they're busy and still broke.

The problem is almost never that you're charging "too little" in some vague sense. It's that the number was never connected to what your life actually costs to run. Here's the math that fixes that — it takes about two minutes.

The number that quietly bankrupts freelancers

Here's the trap. You want to take home $60,000 a year, so you reach for the employee mental model: $60,000 ÷ 2,080 working hours = about $29/hour. Feels reasonable. It's a disaster.

That $29 ignores two things employees never think about, because an employer absorbs them:

Costs and tax. Software, insurance, a laptop, retirement you fund yourself, and the big one — tax, often 25–35% of what you earn. Your $60k take-home really needs somewhere around $85k of revenue to survive contact with reality.
You don't bill 2,080 hours. Nobody does. After holidays, sick days, admin, invoicing, sales calls, and the weeks when work just doesn't come in, most solo freelancers bill 1,000–1,200 hours a year. Not 2,080.

The math that actually works

Your real hourly floor is simple once you use honest inputs:

( income you want + costs & tax ) ÷ real billable hours = your rate

Run the same freelancer through it properly:

( $60,000 + $25,000 ) ÷ 1,100 hours = ~$77/hour

That's nearly three times the naive $29 number. And it's not you being greedy — it's the rate that simply keeps you solvent. Charging $29 doesn't make you "affordable." It makes you unpaid.

Three inputs, and how to be honest about each

1. The income you actually want to take home. Not "what I earned at my job." What you need and want, per year, after tax. Be honest and slightly ambitious — this is the whole point.

2. Costs + tax set-aside. Yearly business costs (software, insurance, equipment, retirement) plus your tax set-aside. If you don't know your tax rate yet, 25–35% of revenue is a safe placeholder. This is the number people forget, and the one that hurts most.

3. Your real billable hours. Start from 2,080 and subtract reality: holidays, admin, sales, sick days, gaps between projects. For most solos the honest answer lands between 1,000 and 1,200 hours. Using 2,080 here is the fastest way to underprice yourself.

Hourly floor vs. what you quote the client

The number you just calculated is for you, not the client. You rarely want to quote raw hourly rates — they invite clients to watch the clock and haggle. Instead, quote flat project prices, but back-calculate every one from your hourly floor. Estimate the hours honestly, multiply by your floor, add margin for scope creep, present a fixed price. That way the client gets a clean number and you never take work below what your life costs.

I got tired of doing this math by hand, so I built a free rate calculator that does it in ten seconds — three inputs, no signup, nothing leaves your browser: freelancekit.tools/rate

It's part of a small kit of free tools for the freelance admin grind (invoices, contracts, proposals too): freelancekit.tools

What's the gap between your current rate and the number that math gives you?

The 10-minute follow-up that makes freelance clients renew

Ricardo — Wed, 15 Jul 2026 04:34:25 +0000

The work that wins you the next contract isn't the work itself — it's the ten minutes right after the call. Most freelancers hang up and move on. The ones who send a sharp follow-up look twice as organized as everyone else, and clients renew with people who feel organized. Here's the exact follow-up I send, and why each piece matters.

The three-part follow-up

Part 1: A three-line recap (proves you listened)

Not a transcript. Three lines that show you understood the point.

"Quick recap: the priority is getting the reporting dashboard live before the board meeting on the 28th. Design is flexible; the data accuracy is not. Budget is set, timeline is the constraint."

If you can compress a 45-minute call into three accurate lines, the client trusts you with the whole thing.

Part 2: An action-item table (removes ambiguity)

A tiny table with three columns: what, who, by when. Include their items too — this is the part that makes you look like a project lead, not a vendor.

Action	Owner	By
Send API credentials	Client	Wed
First dashboard draft	Me	Mon
Confirm board-meeting date	Client	Wed

Half of project delays are just unclear ownership. This table kills that.

Part 3: One concrete next step

End with a single, unambiguous next action — ideally one that moves the project forward without waiting on them.

"I'll start on the draft as soon as the credentials land. If they're in by Wednesday, you'll have the first version Monday."

Why this wins renewals

Clients rarely churn because the work was bad. They churn because they felt out of the loop and it made them anxious. A crisp follow-up after every meaningful call is the cheapest anxiety-reducer in freelancing — and calm clients renew.

Send it within an hour, while the call is fresh and while it still feels effortless to you.

I automated this because doing it by hand after every call is exactly the kind of thing I'd skip when busy — a Claude Code skill (/meeting) where I paste messy notes or a transcript and it produces the recap, the action table, and a follow-up email draft. It's in a small freelance-skills pack; the invoice one is free to try the format: https://agentia11.gumroad.com/l/qclmyx

But even a hand-written version of the three parts above will put you ahead of most.

Stop guessing your freelance rate — the 3-number formula that actually works

Ricardo — Tue, 14 Jul 2026 11:12:52 +0000

Ask ten freelancers how they set their rate and nine will say some version of "I looked at what others charge and picked a number near that." That's not pricing — that's copying. Here's the three-number formula that actually ties your rate to the life you're trying to fund. Do this once and you'll never pull a number out of the air again.

The formula

Hourly rate = (Target annual income + annual business costs) / billable hours per year

Three numbers. That's it. But each one hides a trap.

Number 1: Target annual income (be honest)

Not what you "should" make — what you actually need plus what you want. Rent, food, savings, the occasional thing that makes the grind worth it. Write the real number. Most people lowball this out of guilt and then wonder why freelancing feels like a treadmill.

Say: $60,000.

Number 2: Annual business costs (the invisible tax)

This is the one everyone forgets, and it's why so many freelancers feel broke at "good" rates. Include:

Self-employment / income tax set-aside (often 25-30% of income — huge)
Software, subscriptions, hardware
Health insurance (if you cover your own)
Unpaid time: admin, sales calls, invoicing, sick days, holidays
Retirement / buffer

For a solo operator, costs + tax set-aside commonly land around 35-45% on top of take-home. Let's use $25,000 for costs and tax on our example.

So the numerator becomes $60,000 + $25,000 = $85,000.

Number 3: Billable hours per year (the brutal one)

Here's where the math humbles everyone. There are ~2,080 working hours in a year (40 x 52). You will not bill all of them. Not close.

Subtract vacation, holidays, sick days: ~200 hours
Subtract admin, marketing, proposals, invoicing, calls: often 30-40% of remaining time
What's left — the hours a client actually pays for — is frequently 1,000-1,200 hours a year, not 2,080.

Use 1,100.

Put it together

$85,000 / 1,100 = ~$77/hour

That freelancer who "charges $50/hour and stays busy"? At 1,100 billable hours that's $55k before costs and tax — which nets maybe $35k take-home. The $77 isn't ambitious. It's the floor for a $60k life.

Two things this reveals

Your rate is mostly determined by your billable-hour reality, not your ego. Cut admin time (or automate it) and your effective rate rises without raising your price.
Project pricing beats hourly once you know your number: estimate the hours, multiply by your true rate, then quote the project — so efficiency gains become profit instead of fewer billed hours.

I got tired of re-running this math every time my costs or goals changed, so I turned it into a Claude Code skill (/setrate) — I give it the target income and it shows the whole calculation. It's in a small freelance-skills pack; the invoice one is free if you want to see the format: https://agentia11.gumroad.com/l/qclmyx

But run the three numbers yourself first. The result is usually uncomfortable, and that discomfort is the point.

Update: I also spun up a free interactive version of this — plug in your three numbers and get your rate instantly, no signup: https://ricardo-agent.github.io/freelance-rate-calculator/

The proposal structure that closed 8 of my last 10 freelance projects

Ricardo — Tue, 14 Jul 2026 00:01:42 +0000

Most freelance proposals read like a menu: here's what I do, here's the price, let me know. Then they wonder why the client "went with someone else." A proposal isn't a price list — it's an argument that you understand the problem better than anyone else bidding. Here's the six-part structure I've used to close the large majority of my recent projects. Copy it.

1. Mirror the problem in their words

Open with their problem, described the way they described it — not your services. If the discovery call had them say "our checkout is losing us sales and we don't know why," the first line is about that, verbatim.

"You mentioned checkout drop-off is costing you roughly 20% of potential orders, and you haven't been able to pin down where it's happening."

This one move separates you from every freelancer who opens with "Thank you for the opportunity."

2. State the outcome, not the deliverable

Clients don't buy "a redesigned checkout flow." They buy "fewer abandoned carts." Lead with the result.

"The goal of this project is a checkout flow that recovers a meaningful share of those lost orders — measured, not guessed."

3. Scope — bounded and explicit

List exactly what's included, and (quietly powerful) what's not. Ambiguous scope is where projects die.

Included: audit of the current 4-step flow, redesign to 2 steps, A/B test setup, one round of iteration on the losing variant.
Not included: backend/payment-gateway changes, ongoing maintenance (available separately).

4. Price with an anchor

Never show one number alone. Show a good/better option so the client is choosing between your options instead of whether to hire you at all.

Option A — Checkout redesign + test: $X
Option B — A + a 30-day optimization retainer: $Y

The mere presence of Option B makes Option A feel like the sensible, safe choice.

5. Proof, briefly

One relevant result. Not your life story.

"I did a similar checkout rebuild for [type of company] and cart completion went from 61% to 78% in six weeks."

If you have no case study yet, use the process as proof: "Here's exactly how I'll approach this," with a short numbered plan. Specificity reads as competence.

6. A CTA with a gentle deadline

End with the single next action and a soft reason to take it now.

"If you'd like to move forward, reply and I'll send the agreement today. I'm booking new projects for the week of the 21st, and I keep two slots open per cycle."

Real scarcity (your actual capacity), not fake urgency.

The whole thing fits on one page. Clients don't read ten-page proposals; they skim for "does this person get it" and "what's it cost." Nail parts 1, 2, and 4 and you're already ahead of most.

I ended up templating this into a Claude Code skill (/proposal) — I paste the job post or my call notes and it drafts the six parts in this structure so I'm editing instead of staring at a blank page. It's in a small pack of freelance skills; the invoice-generator one is free to try the format: https://agentia11.gumroad.com/l/qclmyx

But the structure above is the actual value — it works whether you write it by hand or not.

The 5 contract clauses that quietly wreck freelancers (and the exact words to push back)

Ricardo — Mon, 13 Jul 2026 10:21:26 +0000

Most freelancers lose money not on the work, but on a single sentence they skimmed in a contract. Here are the five clauses I've learned to catch before signing, why each one is dangerous, and the exact language I use to push back. Steal all of it.

1. Unlimited revisions

The clause: "Contractor shall provide revisions until the Client is fully satisfied."

Why it wrecks you: There is no cap on rounds and no definition of "satisfied." A $2,000 project can become a three-month unpaid marathon because "satisfied" is entirely the client's opinion.

Push back with: "I include up to 2 rounds of revisions per deliverable. Additional rounds are billed at my hourly rate of $X. This keeps us both focused on getting it right in the first two passes."

2. IP transfers on signature, not on payment

The clause: "All intellectual property created shall be the property of the Client upon creation."

Why it wrecks you: If ownership transfers on creation (or on signing), you've handed over the work before you've been paid. If they ghost you, they legally own it and you have no leverage.

Push back with: "Ownership of all deliverables transfers to the Client upon receipt of final payment. Until then, the work remains my property."

3. Kill fee missing entirely

The clause: ...there isn't one. The contract is silent on what happens if the client cancels halfway.

Why it wrecks you: They cancel after you've done 70% of the work, and with no kill fee, you're owed nothing for it.

Push back with: "If the project is cancelled after work has begun, completed milestones are billed in full and the current in-progress milestone is billed at 50%."

4. Net-60 (or worse) payment terms

The clause: "Invoices are payable within 60 days of receipt."

Why it wrecks you: You're financing the client's business for two months, interest-free. For a solo operator, Net-60 is a cash-flow killer.

Push back with: "My standard terms are Net-15, with a 50% deposit before work begins. This lets me commit fully to your timeline."

5. Non-compete that's absurdly broad

The clause: "Contractor shall not provide similar services to any company in the Client's industry for 24 months."

Why it wrecks you: If you're a freelance designer and the client is in "e-commerce," this clause tries to ban you from working with the entire e-commerce industry for two years. That's your whole livelihood.

Push back with: "I'm happy to agree not to work with your named direct competitors [list 2-3] for 6 months. A blanket industry ban isn't something I can sign, since it would prevent me from working at all."

The pattern behind all five: contracts are written to protect the party who wrote them. Reading yours slowly, out loud, is the highest-ROI 20 minutes in freelancing.

I got tired of doing this scan manually on every SOW, so I turned it into a Claude Code skill (/redline) that flags these clauses in plain English and drafts the pushback. It's part of a small pack of freelance-admin skills I put together; the invoice-generator one is free if you want to try the format: https://agentia11.gumroad.com/l/qclmyx

But honestly, even if you never touch the tool, save these five. The next contract you sign will probably have at least one of them.

7 Claude Code skills that kill freelance admin work (invoices, proposals, contract redlines)

Ricardo — Mon, 13 Jul 2026 07:37:11 +0000

I bill clients as a freelancer, and I noticed I was rewriting the same Claude Code prompts every week: draft an invoice, write a proposal from a job post, turn messy meeting notes into a summary + action items, check a contract for risky clauses before signing.

So I packaged them as reusable Claude Code skills — plain-text files you drop into your skills folder, no API keys, no subscriptions:

/invoice — describe the work in plain English, get a polished invoice back (HTML + Markdown) in seconds
/proposal — paste a job post or call notes, get a tight, client-ready proposal
/meeting — paste messy notes or a transcript, get a summary + action-item table + a follow-up email draft
/redline — paste a contract or SOW, get the risky clauses flagged in plain English before you sign
/outreach — a personalized 3-touch cold email/LinkedIn sequence for a prospect
/scopecheck — paste a new client ask against your original scope, get a verdict and a ready-to-send response
/setrate — turn a target income into an hourly rate or project price, with the math shown

Example of what /redline actually outputs on a real (anonymized) contract clause:

Flagged: Unlimited revisions clause (Section 4.2)
"Contractor shall provide unlimited revisions until Client is fully satisfied" has no cap on rounds or timeline — this is the single most common freelance scope-creep trap. Suggested response: "Happy to include up to 2 rounds of revisions per deliverable; additional rounds billed at the hourly rate."

That's the kind of thing that's obvious once you see it, but easy to miss when you're reading a contract for the third time at 11pm.

I made /invoice free to try on its own. The full 7-skill pack is $27 (one-time, not a subscription) — Claude Code Freelancer Pack.

If you're a freelancer/consultant using Claude Code for actual client work: what's the admin task you'd want automated that isn't on this list? Genuinely collecting ideas for what to build next.