Good morning.

Your AI writes a proposal in ninety seconds.

Then you spend twenty minutes moving it into the doc, filling in the pricing it didn't know about, and rewriting the two paragraphs that assumed the wrong scope.

That’s a waste of time and effort.

In today’s issue, we solve this with the three places a chain leaks between your tools, and one intake-to-draft chain built end to end, with the file that lets it run when you're not sitting in the middle of it.

—Sam

An operator I work with runs a consultancy with about fifteen active accounts and sends six to eight proposals a month.

He'd built a proposal prompt he was proud of, and it was a good one: it asked for the call notes, pulled out scope, wrote in his voice, and produced something he could edit in five minutes instead of writing from scratch.

He'd been trying to get it out of a manual process in a chat window for four months and turn it into a workflow that runs on its own when triggered.

Every attempt broke in a different place: a form that fed it produced proposals with no pricing, a version his ops person ran came back with scope that included work they'd stopped selling months ago, and s on.

He kept concluding that he needed a better prompt, so he kept rewriting the prompt.

The prompt was fine. The problem was that he was answering its follow-up questions from memory on every single run.

He'd paste the call notes, the model would come back asking, and he'd type in:

Twelve or fifteen small facts per proposal, supplied live, written down nowhere.

He'd never noticed he was doing it, because in a chat window that back-and-forth feels like part of using the thing rather than like a step in a process. The chat window worked because he was in it.

That's why the chain wouldn't run without him. Every workflow that lives in a chat window has this problem, and it's the reason the copy-paste survives every attempt to automate it. The generation step is the only part that got faster, so the parts on either side of it are still yours to do by hand.

Everything you’re about to read can be applied to any AI workflow. I’m using proposal generation as an example only. The method, principles, and thinking can be applied to any output or action needed, for any workflow.

So, even if you don’t generate proposals, this issue will still teach you something crucial about how it all works.

A chain has two ends and a middle. Information arrives at one end, an asset comes out the other, and the AI does something in between.

Each of those three points leaks for a different reason, and the fix is different for each, so it helps to know which one is costing you the afternoon.

The intake leak. Material arrives in whatever shape the sender chose: an email thread, a form submission, a call recording, a PDF someone attached, a voice memo you left yourself in the car. Somebody reads all that and re-expresses it as a prompt. That re-expression is a summarizing job, it takes real attention, and it can only be done by someone who understands the account. This is the leak most entrepreneurs assume is the only one.

The context leak. The drafting step needs facts about your business that aren't in the intake: what you charge right now, what's in scope for a given engagement, what you've stopped selling, how you word the terms, which two case studies fit this buyer. Those facts live in your head, which makes you the only person who can run the chain and the only person who can check its output. This is the expensive leak, and it's the one people misdiagnose as a prompting problem.

The last-mile leak. The draft comes out as text in a chat window and has to get into a Google Doc, a CRM field, a proposal tool, a project template. So you select it, copy it, paste it, fix the formatting the paste broke, and fill in the three fields the destination wants that the draft doesn't carry. Each one is small on its own, and six to eight times a month it adds up to a workday.

Patching one of these on its own buys you nothing, since a clean intake still leaves you as the only person who can supply the context, and solving both still leaves you pasting at the end.

All three come out of the same missing piece:

There's no defined thing in the middle that both ends can agree on.

If you're not sure which one is costing you most, the symptom tells you:

Give the middle a shape and the two ends stop having to negotiate with each other.

The Handoff File is one markdown file per job, with a fixed set of fields, that sits between intake and draft. Intake writes into it. The drafting step reads only from it. Nothing gets into the draft that didn't come through the file first, which is what makes the chain runnable by something other than you.

Two properties do the work:

That second property is what makes the output safe to use. A proposal carrying the line no rate discussed on the call tells you what to go find out, while a proposal carrying an invented rate is something you have to catch before it reaches a buyer.

Here's the folder. It's small on purpose, and it holds one chain.

If you already keep a context folder for your agents, point the chain at it and let the drafting step read your offers and voice files from there.

If you don't, a single business-facts.md sitting next to template.md covers it for one chain, and you can grow it later.

Every field exists because something in template.md needs it. That's the whole rule, and it's why you write the template before you write the fields.

Ten fields is about right for a proposal chain, where an onboarding brief runs shorter and a technical scoping doc runs a little longer.

Resist adding a field you can't point to a section of the template for, because every extra field is another thing the intake has to supply or flag as missing.

Here's what one looks like after the skill has run against a call transcript.

The account is anonymized, everything else is the real deal.

Those three lines under Missing would otherwise have been three wrong sentences in a proposal, and the model produced them at no extra cost because the field was sitting there waiting.

Seven steps. The first chain takes an afternoon because you're deciding the shape as you go. The second one takes about an hour, since the folder and the skill already exist and you're only writing a new template.

Step 1. Pick the chain. Choose something you do at least weekly, that takes you more than twenty minutes of typing each time, and where the output has a shape you'd recognize. Proposals, onboarding briefs, weekly account updates, scoped estimates, and post-call recaps all qualify. Skip anything you do monthly, because you'll never build the reps to find the bugs.

Step 2. Write the template first. Open template.md and lay out the finished asset: every section heading, in order, with a line under each saying what belongs there and roughly how long it runs. Pull this from your best recent example rather than inventing it. Twenty minutes. Doing this before anything else feels backward and it's the step that saves you a rewrite, because you can't know what the middle needs to carry until you know what the end has to produce.

Step 3. Derive the fields. Walk your template section by section and ask what input each one needs. Those inputs are your Handoff File fields. Write them into HANDOFF-template.md as empty H2 headings, then add the Missing section at the bottom. If a field doesn't feed a section, cut it.

Step 4. Fix the intake. Get raw material into intake/ without a person moving it. A form can send submissions straight to a doc in that folder, your transcription tool can export call notes there, and email gets in through a forwarding rule plus a folder sync. The bar here is low and it matters: whatever arrives should arrive on its own, in whatever mess it comes in, because normalizing the mess is the skill's job and not yours.

Step 5. Install the skill. The full SKILL.md is below. It reads the intake, fills the Handoff File, flags what's missing, and drafts against the template.

Step 6. Run it backward on three jobs you already know. Point it at three past intakes where you still have the asset you sent, then compare what it produced against what you wrote at the time. You're grading two things:

Three jobs is enough to find most of it, and you'll know within an hour whether the template is wrong.

Step 7. Fix the last mile. Covered in its own section below, because this is where most people give up and it's the cheapest part to solve.

After step six you have a chain that produces a real first draft from raw intake with no prompting in the middle. In the chains I've watched go live, the first month's output is worth sending after a light edit about seven times out of ten, and the other three come back needing a fact the Missing section already told you to go get.

Create a folder called intake-to-draft/ wherever your Claude environment reads skills from, put a SKILL.md inside it, and paste in the block below.

Then tell Claude: run the proposal chain for Northgate.

Two lines in there earn their keep more than the rest:

The last mile has three rungs, and the rule is that you only go up one when the rung below it fails.

Rung one covers more than people expect. The skill already writes files rather than chat text, so the draft turns up as a markdown file in a folder your team has open anyway. Most chains for most businesses never need to leave this rung.

Rung two is worth it once a destination has structure. Google Drive, Notion, HubSpot, Slack, Linear, and Airtable all have MCP connectors now, with a growing list past those. Setup runs from ten minutes to an afternoon depending on how the tool handles auth, and after that the draft arrives in the CRM field or the doc without anyone moving it.

Rung three is where the cost turns ongoing. If you're already running n8n, this is one node on the end of the chain and it's the cleanest place for it. If you're not, you're writing and maintaining a script, so be sure rungs one and two failed before you climb here.

Most entrepreneurs reading this should stop at rung one for their first chain, run it for three weeks, and only then look at what's still annoying. The instinct is to start at rung three because it feels like the real version, and what comes out of that instinct is two weekends spent connecting a chain nobody has tested yet.

Once the chain runs, four pieces need an owner, and for a lot of businesses reading this all four are the same person for a while.

Writing them down separately still matters, because it tells you which one to give away first when you get the chance.

The context files go stale fastest and do the most damage when they do, since a chain reading a stale offers file produces well-written proposals that quote a rate you retired months ago.

The Missing list is where the system improves. Every recurring MISSING item is either a fact that belongs in the context files or a question that belongs on the intake form, and either way it's a five-minute fix that stops the item coming back.

A month of those makes the chain noticeably better than it was on day one, which is why it's the piece to keep for yourself longest. The other three are maintenance once they're set.

The chain you build this week won't be your best one.

Build it anyway, on the job you do most, because the three backward runs in Step 6 hand you something you can't get any other way:

A written list of the facts you've been supplying from memory.

The consultant I opened with had twelve or fifteen of them, and not one existed anywhere outside his head.

That list is why the second chain takes an hour instead of an afternoon, and it's why someone other than you can run the first one.

There's a second thing that happens once a chain runs clean, which is that people start asking you to build them one.

A capability a buyer can watch working on day one is easier to sell than anything you'd have to explain first, and by the end of next week you'll have one.

Next month, the Cortex issues work through how to price that and how to hand it over so it runs without you, whether you're selling it as a service or shipping it as a paid tier in a product you already have.

Want it all delivered to you, ready to be setup, plugged in, and earning you extra cash for your business?

Get in now before the issues go live in September:

Upgrade to Cortex here

Talk soon,
Sam Woods
The Editor

.