You already have templates. A content brief you paste into every new client thread, an outline format you reuse, maybe a tone paragraph you copy from the last client and edit by hand. That's a real starting point, and it's also where most freelancers get stuck: a template is a finished file, so reusing it still means retyping whatever's different this time, and the master copy of your tone rule lives wherever you happened to paste it last. Blocks that compound work differently. You write a piece once, reference it from every place that needs it, and the work you put into that first block keeps paying out as your client list grows.
What "reusable blocks" means, not just copy-paste templates
A prompt template, in the copy-paste sense, is one finished document. You open it, change the client name and a paragraph or two, and send it off. The original stays a template; every copy drifts a little further from it the moment you start editing.
In PAL, the unit you reuse isn't a finished prompt at all. It's a Blend: an ordered stack of blocks, where each block is either plain text or a reference to another Blend. A tone rule, a formatting standard, an intake checklist: each one lives as its own block, written once. A client's working prompt then references the blocks it needs instead of containing a copy of them. Change the block, and every Blend that references it picks up the change the next time you generate, without you touching each client's file by hand.
How compounding works: every new client starts from something, not nothing
The first client you set up this way costs about the same amount of work as writing a normal template. The difference shows up starting with the second client.
Say your tone rule and your output-format block already exist as global Blends, visible across every Project. Client two's Blend references both of those and adds one short block that's actually specific to them. Client five's Blend does the same: reference the tone rule, reference the format, add one client-specific piece. You're not rebuilding the shared parts each time. You're adding one new block per client on top of a foundation that already exists, which is the actual mechanism behind "compounding": the blocks you wrote for client one keep earning their keep for every client after.
Picture it as a ledger instead of a pile of files. Two global blocks, written once, sit underneath five, then ten, then twenty client-specific Blends. Each new client adds one entry to that ledger, not a full rewrite of everything above it. The moment this stops feeling like extra setup and starts feeling like a shortcut is usually somewhere around client three or four, once you notice you're not opening a blank document anymore.
Turning a hard-coded template into variables instead of rewriting text
Some of what changes per client isn't worth a whole new block. A client name, a target keyword, a deadline: these are values, not structure, and PAL treats them that way. Write {{client}} or {{deadline}} directly into a block's text, and PAL scans the Blend and finds every {{token}} automatically. At generation time, what PAL calls Brewing, a form asks you to fill in the current values, and the rest of the Blend renders exactly as written.
This is the piece that turns a template into something reusable across a whole client roster instead of just one client: the block stays the same, and only the filled-in values change per run. For the full mechanics of how variables discover themselves and where they fit against a global block, Prompt Variables: One Template for Every Client, Model, and Task covers that in more depth than fits here.
A freelancer's starter block set
You don't need a large system to get the compounding effect started. Three blocks cover most of what a freelancer working across clients actually needs: a global tone-of-voice block, a global output-format block, and one project-scoped override block per client for whatever's genuinely specific to them, brand terms to avoid, a stricter formatting rule, a different call to action.
Resist the urge to build more than that on day one. A block set that starts too broad, ten shared blocks for every possible situation, tends to sit unused, because you can't tell which one actually applies to the task in front of you. Three blocks you reach for every single time beats ten you have to think about. Add a fourth block only once you notice yourself typing the same paragraph into a client override for the second or third time.
Before you tighten a shared block, it helps to know what depends on it. PAL's usage view shows which Blends reference a given block, so you can see the actual list of client prompts that would change before you change it, not after. The client brand-voice system in the gallery is a working version of exactly this pattern: a shared tone block, a shared formatting block, and a per-client voice profile, assembled into one generator you can open and inspect directly.
Once you generate from a Blend, the output is yours to use wherever you need it: copy it into ChatGPT, Claude, or whichever model that client's work runs through. The block set doesn't care which model comes next. If you're still working out of a folder of separate files rather than a set of blocks, How to Organize AI Prompts is the place to start.