The marketer's job is the loop: five GTM loops you can build this week

TLDR: Engineers have mostly stopped typing prompts into coding agents. They build loops that write the prompts for them, run the agent and check the result before anything ships. Marketers can do the same with tools they already pay for. Below are five loops, each built from real tools: Gojiberry, Clay, Apollo, HubSpot, Fathom, Zapier or n8n, Claude and Buffer. For each loop I give the trigger, the setup steps, the prompt the loop fills in, the check that stops bad output, and the record that lets the loop improve. Build one this week. Build the rest once the first one works.

The six parts of a loop

Every loop in this post has the same six parts. If you can't name all six for something you've built, find the missing part before you switch it on.

1. Trigger. Something in the world starts the run: a prospect engages with a competitor's post, a target company raises money, a deal closes lost, a call recording finishes.
2. Context. The loop fetches what the agent needs to do good work: CRM history, the transcript, your messaging doc, the emails that got replies last month.
3. Prompt. You write a template once. The loop fills in the blanks on every run. You stop writing prompts and start maintaining templates.
4. Work. The agent drafts the message, the post or the summary.
5. Check. Something scores the output before a buyer sees it. That might be hard rules written as formulas, a second model with a yes/no rubric, or a person approving each item.
6. Record. The loop logs what it did and, later, what happened. The next run, and your weekly review, reads that record.

Without the record you have a pipeline. With it, you have a loop that gets better each week.

Before you build: the spine

All five loops read from and write to the same three things. Set these up first. It takes an afternoon; the loops will be much worse without them.

1. A messaging doc

Make one plain document, in Google Docs or Notion, with these sections:

• Who we sell to. Job titles, company size, industries and the trigger events that make them buy.
• Problems, in buyers' words. Copy phrases from call transcripts and emails, not from your website. "We spend Fridays reconciling three spreadsheets" beats "operational inefficiency."
• Proof we can use. Customer results you have permission to cite, each with its source. If a number isn't on this list, no loop may use it.
• Never say. Claims you can't make, words you hate, competitor names you won't mention, anything legal has flagged.
• Voice. Five to ten rules. Keep them concrete: "No exclamation marks." "One ask per message." "Write like a busy founder texting a peer."

Every prompt template in this post pastes in sections of this doc. When you change the doc, every loop changes with it. Loop 5 exists mainly to keep this doc honest.

2. A rubric for each channel

Write five to eight yes/no questions per channel (LinkedIn DM, cold email, LinkedIn post). Draw them from your best past work and from what buyers have complained about. Use yes/no rather than a 1–10 score: models drift toward giving everything a seven, while a yes/no answer gives you something you can act on.

A starting rubric for a cold email opener:

1. Does the first sentence refer to a specific, verifiable event at the prospect's company?
2. Does the email name one problem from the "Problems" section of the messaging doc?
3. Is every factual claim either from the research provided or from the "Proof" section?
4. Does the email make exactly one ask?
5. Is it under 90 words?
6. Would a skeptical buyer reading it on their phone know within five seconds why it was sent to them?
7. Does it avoid every phrase on the "Never say" list?

3. One system of record

Use HubSpot as the place every loop logs to. Create four custom contact properties:

• loop_name (dropdown: linkedin_intent, signal_email, champion, content, lost_deal)
• signal_type (dropdown: competitor_engagement, keyword_engagement, job_change, funding, hiring, new_leader, web_intent)
• template_version (single-line text, such as "email-v3")
• judge_passed (yes/no)

These four fields make the weekly review possible. Without them, you can't tell which signal, which template version or which judge decision led to a reply. If you skip anything in this post, don't skip these.

Now the loops.

---

Loop 1: The LinkedIn intent loop

Tools: Gojiberry, Slack, HubSpot What it does: It finds people who are already engaging with your topic or your competitors on LinkedIn, starts a conversation that refers to what they did, and learns which signals lead to real conversations.

Gojiberry watches LinkedIn for intent signals and runs outreach from your own LinkedIn account. In setup it offers signals such as recent job changes, recent fundraising, active hiring and highly active profiles. It also offers keyword tracking (people who post about, like or engage with topics you choose) and competitor tracking (people who follow or engage with competitors you name). It connects to HubSpot, Pipedrive, Slack, Clay, Instantly, Lemlist, Zapier and webhooks; it also has an API and MCP support.

Setup

1. Define your ICP in Gojiberry. Start from the job titles it suggests and cut any that don't match "Who we sell to" in your messaging doc. Set industries, locations and company size. Use the exclusions: service providers and freelancers, people marked Open to Work, and your competitors' own employees. Teams who skip this step get most of their junk leads from it.
2. Choose two or three signals, not all of them. For most B2B companies, start with competitor engagement and keyword engagement. Pick keywords from the "Problems" section of your messaging doc, using the words buyers use rather than category jargon. Name three to five competitors.
3. Run one campaign per signal. If you put every signal into one campaign, you can't tell later which one produced the conversations. Separate campaigns turn each signal into its own experiment.
4. Write a custom AI template. Gojiberry keeps custom AI templates under Account Settings. Here's a starting template for the first message after a connection is accepted:

You are writing a LinkedIn message from [your name], [your role] at [company].

The prospect: {first_name}, {title} at {company}.
Why we're reaching out: {signal_description}
(For example: they commented on a post about vendor consolidation;
they follow [competitor]; they started a new role 3 weeks ago.)

Our buyers describe the problem like this:
[paste 3 phrases from the "Problems" section of the messaging doc]

Rules:
- Under 60 words.
- First line refers to what they did, plainly. Don't pretend you stumbled on it.
- Ask one question about their situation. Do not pitch. Do not link.
- No flattery about their post.
- [paste the "Voice" and "Never say" sections]

1. Set a gentle sequence. Gojiberry generates a sequence you can edit; a typical LinkedIn-only version sends a connection request, then messages on days 1, 3 and 6. Cut it to the request plus two messages. Set weekly limits on invites and messages well below the maximum. Your LinkedIn account is the one asset in this loop you can't replace.
2. Turn on Review Mode for the first two weeks. Review Mode lets you approve each lead and each message before Gojiberry sends it. Approve, edit or reject every one. When you reject a lead, mark it as a poor fit in Contacts. Gojiberry learns from that good-fit and poor-fit feedback.
3. Connect Slack and HubSpot. Send reply alerts to a Slack channel so you answer within the hour. Sync contacts who reply into HubSpot; set loop_name = linkedin_intent, signal_type to the campaign's signal and template_version to "li-v1."

The check

For the first two weeks, you are the judge. After that, keep Review Mode on for messages and switch it off only for leads, once fewer than one lead in ten needs rejecting. While you review, keep a running note of every edit you make. If you make the same edit three times, add it to the template as a rule.

The record and the weekly review

Every Friday, look at each campaign:

• connection acceptance rate
• reply rate after acceptance
• replies that turned into a meeting

Then make one change, and only one:

• Kill the weakest signal and test a new one. For example, swap "active hiring" for a new competitor.
• Or edit the template and bump template_version to "li-v2."

If you change two things at once, you won't know which one moved the number. Expect the competitor-engagement campaign to look good on acceptance rate and worse on meetings, because people who follow competitors include students, job seekers and your competitors' partners. You'll see from the record whether that holds for your market.

---

Loop 2: The signal-to-email loop

Tools: Clay, Claude (inside Clay), Apollo, HubSpot What it does: It watches your target accounts for buying events, finds the right person, writes an opener tied to that event, checks the opener against your rubric and only sends the ones that pass.

Clay's signals cover job changes, promotions, new hires, job postings, news and fundraising, topic intent and web intent. Web intent needs the Growth plan. Signals run on a schedule you choose, from daily to quarterly. For this loop you also need the Growth plan's webhook source and HTTP API column, so budget for Growth, which starts around $495 a month.

Setup

Table 1: Accounts.

1. Import your target account list with company domains. Turn on auto-dedupe on the domain column.
2. Add signals. A good starting set:
   • Job postings, filtered to roles your product supports. If you sell sales tooling, a company hiring five SDRs is a buying event.
   • News & fundraising.
   • New hires, filtered to leaders in your buyer role. New leaders often review vendors in their first months.
   • Web intent, if you're on Growth and your site gets enough traffic.
3. Set signals to run weekly. Keep "Update existing rows" off so only new events run; use "Keep existing results" on auto-run so you don't pay twice for the same account.

Table 2: Contacts (one row per signal event).

1. Find the person. For each account with a new signal, run a contact waterfall for your buyer persona. Clay tries providers in order and stops at the first valid result. Turn on "Only mark 'Safe to Send' emails as valid" so catch-all addresses don't slip through.
2. Research one fact. Add a Claygent column that answers one narrow question with evidence. Don't ask for a company summary. Ask something like this:

Find the source for this event: {signal_description} at {company_domain}.
Return JSON:
{
  "event_confirmed": true/false,
  "event_detail": "one sentence, plain facts only",
  "source_url": "...",
  "date": "YYYY-MM-DD"
}
If you can't find a source, return event_confirmed: false. Do not guess.

1. Write the opener. Add a "Use AI" column, choose a Claude model, and add "Only run if" event_confirmed is true. Clay doesn't charge for runs that don't happen, so the condition saves money as well as embarrassment.

Write the first two sentences of a cold email.

Prospect: {first_name}, {title} at {company}.
Event: {event_detail} (source: {source_url}, {date})
Problem this event usually creates, in buyers' words:
[paste the matching line from the "Problems" section]
Proof you may use, and no other:
[paste the "Proof" section]

Rules:
- Sentence 1 states the event plainly.
- Sentence 2 names the problem the event usually creates, as a question.
- Under 45 words total.
- No compliments, no "I noticed", no "congrats".
- [paste "Voice" and "Never say"]

Return only the two sentences.

1. Judge the opener. Add a second "Use AI" column with a different instruction and, ideally, a different model from the writer. Give it the rubric and ask for structured output:

You are reviewing a cold email opener. Answer each question yes or no.
Be strict. If unsure, answer no.

Opener: {opener}
Research provided to the writer: {event_detail}, {source_url}
Proof allowed: [paste "Proof" section]
Never-say list: [paste]

Return JSON:
{"q1_specific_event": "yes/no", "q2_names_problem": "yes/no",
 "q3_claims_supported": "yes/no", "q4_one_ask": "yes/no",
 "q5_never_say_clear": "yes/no", "fail_reason": "one line or empty"}

1. Add hard rules as formulas. Add a formula column for word count and one that flags banned phrases. Formulas are cheap, fast and never argue with themselves.
2. Add a pass/fail column. It passes only if every judge answer is "yes" and both formula checks pass.
3. Send to Apollo. Add an HTTP API column with "Only run if" pass is true. It calls Apollo's API to create or update the contact, writes the opener into an Apollo custom field and adds the contact to a sequence. In the sequence's first email, put the custom field at the top and write the rest by hand once: two lines on what you do and a soft ask. In Apollo, set the contact's signal_type, template_version and judge_passed fields so they sync to HubSpot.
4. Keep the failures. Don't delete rows that fail. Filter them into a view called "Judge rejected." You'll need them in the weekly review.

The record and the weekly review

Apollo syncs sequence activity to HubSpot, so by the end of the week each contact carries its signal, template version and reply status. Every Friday:

• Compare reply rates by signal. Drop signals that produce confirmed events but no replies. Promote signals that produce replies.
• Read ten rejected openers. If the judge rejected good ones, a rubric question is too strict. Rewrite it.
• Calibrate the judge once a month. Send a small batch of openers that failed exactly one rubric question, with a person approving each. If they get replies at the same rate as passing openers, that question isn't predicting anything; cut it. If they do worse, the question is earning its keep.

Agents learn to please whatever judge you give them. If the judge rewards specifics, the writer starts inventing them, which is why question 3 checks every claim against the research. If the judge rewards short copy, the writer eventually cuts the ask. Read the passing openers every week, not only the numbers.

---

Loop 3: The champion loop

Tools: HubSpot, Apollo What it does: It notices when someone who already bought from you moves to a new company, then gets a personal note from the account owner in front of them within a week.

This loop sends very few messages; each one is worth far more than a cold email. Your former champions already trust you. When one lands at a new company, they usually spend their first months fixing things; they reach for tools they know.

Apollo Workflows can start when a contact changes jobs. Apollo now runs waterfall enrichment on job-change flows, including scheduled ones. Workflows can then add contacts to sequences, create tasks, update fields and send notifications.

Setup

1. Build the champion list in HubSpot. Create an active list of contacts who meet any of these conditions:

   • associated with a closed-won deal and listed as a decision-maker or champion on it
   • gave you an NPS score of 9 or 10
   • appeared in a case study or gave you a quote

   Sync that list to Apollo.

2. Create the Apollo workflow.

   • Trigger: contact changes jobs.
   • Condition: the new company matches your ICP (size, industry, geography) and isn't already a customer.
   • Action 1: add the contact to a sequence called "Champion moved."
   • Action 2: create a task for the original account owner, due in two days.
   • Action 3: post a notification to the sales channel in Slack.

3. Make the first sequence step a manual email. This loop shouldn't send anything automatically. The audience is small and named; every one of these people knows your team by name. The task gives the owner what they need to write the note:

   • what the champion bought and when
   • the result they got (from the deal notes or the case study)
   • one line on the new company, from Apollo's AI Research

4. Give the owner a template, not a script:

Subject: congrats on {new_company}

[One line, personal, that only you could write.]

When we worked together at {old_company}, you [result in plain words].
If {new_company} is dealing with anything like that, I'd be glad to
help you skip the setup work this time.

Either way, good luck in the new role.

1. Write a second workflow for the reverse case. When a champion leaves a current customer, create a task for the customer success owner: "Your champion at {old_company} just left. Find and meet the new owner within 14 days." Customers who lose their champion often drift away at renewal, so the same trigger protects revenue you already have.

The check

The account owner checks every email. Apollo's AI can draft, but the owner reads and rewrites before sending. If owners start sending the draft untouched, the loop has lost the thing that makes it work.

The record

Set loop_name = champion on every contact who enters the sequence. Once a quarter, count the meetings, pipeline and revenue the loop produced. For most B2B companies this is the highest-converting loop in the post, and the cheapest to run. If it produces nothing, check the champion list first: it's usually too small because nobody recorded champions on closed-won deals. Fix that in your deal process before you blame the loop.

---

Loop 4: The call-to-content loop

Tools: Fathom (or Gong, or Granola), Zapier or n8n, Claude, Google Sheets, Buffer What it does: It turns the questions buyers ask on calls into LinkedIn posts that answer them, schedules those posts for your approval and learns which topics bring people in.

Most companies write content from what the marketing team finds interesting. This loop writes it from what buyers asked last week, in their words.

Buffer reopened its public API on May 27, 2026; it's included on every plan, including Free. It uses GraphQL. A createPost mutation can add a post to your queue or schedule it for an exact time. On a channel set to require approval, a post created through the API arrives as a draft awaiting approval rather than going into the queue. Posts expose a metrics field you can read with a personal API key. Buffer also runs a remote MCP server, if you'd rather drive it from Claude directly.

Setup

Part A: Build a question bank after every call.

1. Trigger: Fathom finishes a meeting transcript. Zapier has a ready Fathom trigger; in n8n, use a webhook. Add a filter so only external calls (sales, customer success) pass.
2. Extract. Send the transcript to Claude with this prompt:

Below is a transcript of a call between our team and a buyer or customer.

List every question or concern the buyer raised about the problem,
the category, the decision or the risks. Ignore scheduling and small talk.

For each one return:
- "question": the buyer's question, rewritten as a general question
  anyone in their role might ask. Remove all names, company names,
  numbers and identifying details.
- "buyer_words": a short phrase close to how they put it, with
  identifying details removed.
- "stage": discovery / evaluation / negotiation / customer

Return a JSON array. If there are none, return [].

Transcript:
{transcript}

1. Store. Append each item as a row in a Google Sheet called "Question bank," with the date. Add a column that groups similar questions; a weekly Claude pass can cluster them, or you can do it by hand in ten minutes.

Part B: Draft posts every Monday.

1. Trigger: every Monday at 7am.
2. Pick topics. Take the three question clusters asked most often in the last 30 days that you haven't posted about in the last 60.
3. Draft. For each topic, send Claude this template:

Write a LinkedIn post from [your name] answering this question,
which buyers asked us {count} times this month:

"{question}"
How buyers put it: {buyer_words examples}

What we believe about this: [paste the relevant part of the messaging doc]
Proof you may use, and no other: [paste the "Proof" section]

Two of our posts that did well recently, for voice and length only.
Don't copy their topics:
{top_post_1}
{top_post_2}

Rules:
- 120 to 220 words.
- Answer the question in the first two lines.
- One concrete example. No customer names.
- No hashtags. No "here's the thing". No closing question to farm comments.
- [paste "Voice" and "Never say"]

1. Check. Run each draft through a second Claude call with your LinkedIn post rubric, plus code checks for word count, banned phrases and anything that looks like a customer or company name. Drafts that fail go back once with the failure reason attached. If a draft fails twice, drop it.
2. Schedule. Set your LinkedIn channel in Buffer to require approval. Send passing drafts with createPost, using addToQueue. They'll land in Buffer as drafts awaiting your approval. You read three posts, edit, approve and get back to work.

Part C: Learn what worked.

1. Every Friday, pull metrics for the week's posts through the Buffer API and write them to the sheet next to each post's topic.
2. Feed winners back in. Replace {top_post_1} and {top_post_2} with this month's two best performers. Mark topic clusters whose posts flopped so the picker skips them for 90 days.
3. Send the bank to Loop 5. Questions tagged "negotiation" are often objections in disguise. Link the sheet into the lost-deal review.

What to watch

Two things go wrong here. First, privacy: a careless extraction step will put a customer's numbers into a public post. The prompt strips identifiers and the code check catches names; still, read every post before you approve it. Second, sameness: if the top-post examples never change, every post starts to read alike. Rotate them monthly; now and then, write a post yourself on a topic the bank never surfaced.

---

Loop 5: The lost-deal loop

Tools: HubSpot (workflows, Breeze Data Agent or Data Hub webhooks), n8n or Zapier, Claude What it does: It reads every lost deal, records why you lost it in a form you can count, and proposes one change to your messaging doc each month. This is the loop that improves the other four.

The first four loops all paste sections of the messaging doc into their prompts. If that doc is wrong, every loop is wrong at scale. Loop 5 checks the doc against the one source that doesn't flatter you: deals you lost.

You have two ways to run the AI step inside HubSpot:

• Breeze Data Agent. Its workflow actions include Custom Prompt, which analyzes or categorizes record data, and Fill Smart Property. HubSpot charges these in credits, roughly 10 credits per run in current guides. This option is easier to set up.
• Send a webhook to n8n or Zapier, which calls Claude. This needs Data Hub Professional or Enterprise. You can map fields from the response into later workflow steps, which gives you more control over the prompt and the model.

Setup

1. Add deal properties:
   • loss_category (dropdown, a fixed list such as: price, timing, chose_competitor, no_decision, missing_feature, poor_fit, champion_left, other)
   • loss_evidence (multi-line text)
   • loss_competitor (single-line text)
   • loss_owner_agrees (yes/no)
2. Create a deal workflow. Trigger it when the deal stage becomes Closed Lost.
3. Gather context. Pass the deal's notes, associated emails, call summaries (from Fathom or Apollo Conversations) and the free-text loss reason the rep typed.
4. Run the classification. Use the Data Agent Custom Prompt action or the webhook route with this prompt:

You are classifying why a B2B deal was lost. Use only the material below.

Deal: {deal_name}, amount {amount}, days open {days_open}
Rep's stated reason: {closed_lost_reason}
Notes, emails and call summaries:
{context}

Return JSON:
{
  "loss_category": one of [price, timing, chose_competitor, no_decision,
                   missing_feature, poor_fit, champion_left, other],
  "loss_evidence": "two or three sentences quoting or closely
                    paraphrasing what the buyer said",
  "loss_competitor": "name or empty",
  "rep_reason_matches_evidence": true/false
}
If the material doesn't support a category, use "other" and say why.

1. Write back. Map the outputs to the deal properties with an Edit records step.
2. Ask the owner. Create a task for the deal owner: "Lost-deal summary for {deal_name}. Agree? Set loss_owner_agrees." This is the human check; it doubles as calibration: when reps disagree often, the prompt is wrong, or the reps are.
3. Flag mismatches. If rep_reason_matches_evidence is false, notify the sales lead. Reps write "price" more often than buyers say it; the evidence usually shows something else, such as no clear owner on the buyer's side or a decision that kept slipping.

The monthly review: the outer loop

On the first Monday of each month, build a HubSpot report of lost deals by loss_category, for deals where the owner agreed. Then:

1. Read the evidence for the largest category, every deal of it. This takes about 20 minutes and teaches you more than any dashboard.
2. Write one change to the messaging doc. Make it one change, specific and dated. For example: if "no_decision" leads three months running, add a line to "Problems" about the cost of waiting and a proof point about how fast customers get set up.
3. Bump the template versions in Loops 1, 2 and 4 so the record separates before and after.
4. Check ICP drift. If "poor_fit" keeps growing, tighten the ICP filters in Gojiberry and Clay. The other loops are pulling in people who will never buy.

This is the only loop that edits the messaging doc; a person makes every edit. Don't let any loop rewrite its own instructions or its own judge. Engineers learned this early: if you let an agent edit the tests, it makes them pass.

---

The weekly review

The point of all this is that you stop reading every message and start reading the system. Once the loops run, block an hour a week:

Then once a month, run the Loop 5 review and edit the messaging doc.

What this costs and where it breaks

Rough monthly cost, from the vendors' current published pricing:

• Gojiberry Pro: about $99 for two LinkedIn senders.
• Clay Growth: from about $495. You need Growth for the webhook source, the HTTP API column and web intent.
• Apollo: a plan with sequences and workflows.
• HubSpot: whichever plan you already have. Add Data Hub Professional only if you want the webhook route in Loop 5.
• Buffer: the API comes with every plan, including Free.
• Claude and n8n or Zapier: usage-based, small at these volumes.

Where it breaks:

• Your buyers aren't a test suite. Engineers rerun tests forever for free. Every message to a real buyer spends some of their patience, your LinkedIn account's standing and your domain's reputation. Keep volume high only where the audience is large and anonymous. Keep a person approving each send where the audience is small and named, as in Loop 3.
• Marketing loops fail quietly. When a coding loop breaks, a test fails and it stops. When a marketing loop breaks, it can send bland or wrong messages for weeks before anyone notices replies sliding. The weekly review is your alarm, so don't skip it.
• Judges drift. A rubric that predicted replies in March may not predict them in September. Calibrate monthly against the market, as described in Loop 2.
• Thin context. If your HubSpot notes are empty, Loop 5 has nothing to read. If nobody marks champions on closed-won deals, Loop 3 has nobody to watch. The loops will expose these gaps in your process quickly. Fix the process; don't paper over it with a cleverer prompt.

Where to start

If you're a small team, start with Loop 3. It's the cheapest, the most likely to pay off and needs no new tools if you already have HubSpot and Apollo. Then build Loop 5, because it improves everything you build after it. Then pick Loop 1 or Loop 2, whichever suits how your buyers prefer to be reached, and finish with Loop 4.

Once the first loop works, later ones go faster, because you reuse the messaging doc, the rubric format, the HubSpot fields and the weekly review.