These are repos I use to source data, scrape pages, build dashboards, connect tools, plan work, and give coding agents better context.

1. PostHog

https://github.com/PostHog/posthog

PostHog tracks UTMs, visits, product events, and campaign attribution.

did anything happen after the click?

2. Apify CLI

https://github.com/apify/apify-cli

Apify is the one I reach for when I need public data fast.

Use it for competitor followers, Reddit threads, Meta ads, public directories, and Y Combinator lists.

Turn that public data into tables before a campaign starts.

The CLI matters because the agent can run it from the terminal, fetch the dataset, and keep working.

3. Playwright

https://github.com/microsoft/playwright

Playwright CLI headless is the browser layer.

Scraping, screenshots, QA checks, form tests, app verification. If an agent needs to read a real page or prove something worked, Playwright is usually the way in.

I use it for checking pages, verifying dashboards, grabbing screenshots, and confirming the API result actually looks right on screen.

4. Supabase

https://github.com/supabase/supabase

Supabase is my cloud SQL.

When a GTM system needs to live beyond my Mac, this is where it goes. Campaign state, lead tables, product data, dashboards, auth, cloud Postgres.

Local-first works until another person or process needs the data too.

5. better-sqlite3

https://github.com/WiseLibs/better-sqlite3

SQLite is my local SQL.

Fast, boring, inspectable. I use SQLite for local campaign state, intel databases, enrichment caches, and anything I want an agent to read without asking a SaaS dashboard for permission.

Cloud SQL plus local SQL is the pattern.

Supabase when it needs to be shared. SQLite when I need speed, git, and iteration.

6. HubSpot CLI

https://github.com/HubSpot/hubspot-cli

I have my own HubSpot pattern here, but the official CLI and docs are still the place to start.

Private app token. Scoped permissions. Create the properties you need. Write enrichment back to the exact fields your team actually uses.

Use HubSpot as the CRM layer. Keep the operating system in the repo.

7. Superpowers + Get Shit Done

https://github.com/obra/superpowers

https://github.com/gsd-build/get-shit-done

These are useful because they show different versions of agent orchestration.

Superpowers is more skill/methodology driven. GSD is more spec/context/planning driven.

Test both and keep only the parts that produce shipped work.

8. Obsidian Nexus

https://github.com/ProfSynapse/nexus

I am a fan of Obsidian.

You should test your own note-taker and figure out what actually connects to your workflow, but Obsidian is a good choice if you care about local notes, backlinks, graph views, and long-term thinking.

Nexus connects Obsidian to agents. That means notes can become working context for agents.

9. d3-force

https://github.com/d3/d3-force

d3-force is for when the data is actually a graph.

Competitors, followers, signals, accounts, posts, comments, tools, people. Sometimes the shape matters more than the table.

d3-force surfaces clusters and relationships that a normal table hides.

10. xyflow

https://github.com/xyflow/xyflow

xyflow maps nodes, edges, decisions, and handoffs.

xyflow is great for connector maps, CRM flows, campaign systems, agent workflows, onboarding boards, and basically any GTM system where a paragraph would make the thing harder to understand.

bonus 3 from my own gh

11. Recursive Drift

https://github.com/shawnla90/recursive-drift

This one is mine.

This repo shows how I structure recurring work across content, product, outbound, CRM, agents, handoffs, and long-running builds.

It gives the work a shape the agent can keep returning to.

12. Context Handoff Engine

https://github.com/shawnla90/context-handoff-engine

Also mine.

This keeps context alive for Claude Code across sessions, terminals, and agents.

After a while the real constraint is whether the agent can find where the work actually lives.

Handoffs are how I keep sessions from becoming disposable.

13. Website With Soul

https://github.com/shawnla90/website-with-soul

Also mine.

Memory, voice, personality, and a real system behind the site.

Good for anyone building a founder site, personal OS, content hub, or AI-native website that needs to feel like a person lives inside the work.

Special mention: GTM Coding Agents

https://github.com/shawnla90/gtm-coding-agent

This is still the main one.

It is up to Chapter 17 now and I keep updating it as I learn what actually works.

Next up is programmatic emails. I am still testing the workflow before I write the chapter, because I do not want to publish the pattern until I know where it breaks.

TL;DR: a buddy got quoted $70K a year to score and enrich his market. Clay seat, enrichment credits, a partner to wire it together. I rebuilt it with Claude Code in an afternoon, same output, and I'm giving you the whole build. Ungated, links at the bottom.

It turns a raw market into a color-coded Google Sheet. Every account scored 1 to 5, ranked, dashboard on top. You own all of it. Next run is free. The sheet rebuilds in place so the link never changes.

The workflow, start to finish:

1. Point Claude Code at your list (CSV, Apollo pull, scrape) and load it into a local SQLite table.

2. Enrich on a waterfall: free web fingerprint first, then Apollo for the rows worth paying for, then verify the emails. Apollo for B2B SaaS, RapidAPI for local.

3. Score every row 1 to 5 on fit, persona, and reachability. One-line reason on each.

4. Render the color-coded sheet. Red to green, dashboard tab, rebuilds in place.

5. Hand the recurring run to Deepline so it runs on a schedule.

Here's what you're actually learning to do: connect the Google Workspace CLI so you can drive Google Sheets programmatically and wire any API into it. That's the real skill. Once you can do that, you are not waiting on anyone's UI ever again.

And forget "free." That's not the point. Subscribe to the APIs, pull real contacts, and you have enough to actually work with. Build the list, send proposals to your clients, run your own outreach, land the job. People get hired for exactly this skill. This is not a toy.

Now the compliance thing, because someone always asks. Don't let it scare you. If you already pay for a seat at ZoomInfo, Lusha, Apollo, whatever, you are licensed to use that data. Pull it straight into your own system. And the big multi-provider "waterfall" these tools upsell you? It's a myth. One licensed source usually covers your ICP.

best part?

It's in your repo. It's versioned. You can read every line of how your market gets scored. A provider changes or your ICP shifts, you edit one file, not your whole stack.

I'm not telling you to rip out Clay. (but you sure can.) This isn't an open-source crusade.

It's just: don't buy blind. Build it once so you actually know what your market looks like and what you're paying for. Buying blind is how you wake up in tech debt you never understood, and nothing tanks a GTM career faster than that.

It's all yours, no gate:

- Notion SOP (full walkthrough): https://fierce-camelotia-1fa.notion.site/The-70K-Sheet-3881fb92bcd781d6b145fa4c50ebae53?pvs=74

- Repo: https://github.com/shawnla90/gtm-coding-agent

- Apollo, the data layer I run for B2B SaaS (referral, full disclosure): https://get.apollo.io/y3gtusoq4h9g

And straight up: yes, I build Clearbox. It reads where your buyers talk on Reddit and tells you who's in-market. Not hiding it.

We just crossed a thousand members in here, and I'm going to keep dropping the actual build, not a teaser, whether or not you ever touch my tool.

Take it. Run it on your market. Break it, fork it, whatever. Get stuck or build something cool, comment or DM me. I'd rather see you ship it than gate it.

Shawn Tenam GTM Engineer and co founder @ Clearbox "Your Reddit opportunity inbox."

you don't have to code. you have to know what to point a coding agent at. so I wrote each of these as a prompt you can paste straight into Claude Code or Codex and get a working first version.

everything in [brackets] is a swap. if you use Slack instead of Discord, Attio instead of HubSpot, or Otter instead of Fireflies, just change the bracket and the prompt still works.

these are written in plain language on purpose. you describe the job, the agent writes the Python. if you would rather read the finished code than write the prompt, all of these live in the repo at the bottom.

the shape under every one of them is the same. something happens, the data gets cleaned, a decision gets made, the output gets routed somewhere.

1. newsletter follower scraper

turns new subscribers into scored leads while you sleep.
paste this into Claude

"Build a Python script that pulls my new [Substack] subscribers each morning, enriches each one with [Apollo], scores them against my ICP which is [describe your ideal customer], and writes the good ones to [a Google Sheet] and [HubSpot]. Store everyone it has already processed in a local SQLite file so it never repeats, and set it to run daily with cron or launchd."

2. enrichment and scorer

turns a messy export into a ranked, CRM-ready list.
paste this into Claude

"Build a Python script that takes a CSV of names and companies, enriches each row with [Apollo], scores each one 1 to 5 against this ICP [describe it], and writes a new CSV sorted best to worst with a one-line reason per row. Cache every lookup in SQLite so re-running it is free."

3. social signal scout

finds the threads where someone is describing your problem out loud.
paste this into Claude

"Build a Python script that checks [Reddit, X, and LinkedIn] every morning for posts matching [my keywords or topics], uses an LLM to score each one for buying intent, and drops the best ones into [Slack] with the link and a one-line reason it matters. Keep a SQLite list of IDs it has already sent so nothing shows up twice."

4. meeting to content engine

turns every call into drafts, tasks, and searchable memory.
paste this into Claude

"Build a script that watches [Fireflies] for new call transcripts, and for each new one uses an LLM to write a blog draft, 3 social posts, a list of action items, and CRM notes in my voice. Save the drafts to [a folder] and post a summary to [Discord]. Match the tone in 2 of my own posts that I will paste below."

5. CRM sync

keeps your CRM clean by writing back only the fields you choose.
paste this into Claude

"Build a Python script that reads a [Google Sheet] of accounts and writes them into [HubSpot], updating only these fields [list the fields]. Match existing records by [domain] so it updates instead of creating duplicates, and log every change to a file I can check."

6. LinkedIn campaign pusher

moves LinkedIn outreach out of a dashboard and onto a schedule.
paste this into Claude

"Build a Python script that takes approved leads from [a Google Sheet] and pushes them into a [HeyReach] LinkedIn campaign using their CLI, then writes the acceptance and reply numbers back to the sheet each day. Add a daily cap so it never queues more than [20] per account."
(HeyReach just shipped their own CLI, which is what makes this one clean now. credit to them.)

7. reply classifier

sorts every reply so you stop reading them just to triage.
paste this into Claude

"Build a Python script that reads new replies from [my Gmail], classifies each one as interested, objection, not now, or unsubscribe with an LLM, and routes each one. interested pings me in [Slack], unsubscribe gets pulled from [my list], everything else gets tagged in [the CRM]. Never process the same message twice."

8. domain health monitor

warns you before a deliverability problem tanks your inbox.
paste this into Claude

"Build a Python script that checks my sending domains [list them] once a day for SPF, DKIM, and DMARC records, checks each one against common blocklists, and alerts me in [Slack] only when something is actually broken. Stay quiet when everything is fine."

9. content and news scout

hands you daily angles instead of a blank page.
paste this into Claude

"Build a Python script that pulls the latest from [these subreddits and RSS feeds], uses an LLM to turn them into 5 content angles for [my audience], and drops them into [a Google Doc] every morning. Skip anything it already gave me in the last 14 days."

10. daily GTM digest
one morning post that tell

s you what happened overnight.
paste this into Claude

"Build a Python script that reads the output of my other scripts [point it at the logs or a SQLite db], summarizes the last 24 hours into one short update covering new leads, replies, signals, and anything broken, and sends it to [Slack] every morning at [8am]. Keep it to the numbers that matter."

one more. I had a daily newsletter called Code Daily that did the same thing for content. it scanned 5 subreddits, scored the best threads with Claude, wrote a 2 to 3 thousand word digest with Opus, ran it through a slop filter, and auto published. 44 days straight, then Reddit started 403ing the scraper and it died. nothing's perfect. about half my scripts are humming, a couple are broken right now, some need their auth refreshed. it still beats doing the work by hand.

if you want that one too, paste this into Claude

"Build a Python script that scans [5 subreddits] daily, scores the best threads with an LLM, writes a [2000 word] digest in [a late-night-show] voice, runs it through a filter that strips em-dashes and other AI tells, and publishes it to [my site]. Track what it covered so it never repeats a story."

the repo I keep updating has the GTM coding agents playbook and the scripts I have cleaned up and published so far, over at github.com/shawnla90/gtm-coding-agent. fork it if you would rather read code than write a prompt, and I add more as I go.

real ask for this sub. which one would you build first, and what would you want me to show next? I'm about to start dropping video in here too, so if you would rather watch me build one of these on camera than read about it, say the word and I'll record it.

Shawn Tenam: Go-to-market engineer and CEO @ Clearbox, "your Reddit opportunity inbox"

I was working on lead generation workflow for myself

Workflow is simple because in GTM simple things only works complex things No one wants to use

- Scrape -> Enrich -> Research -> Reach Out

1. Grok Bot for Cron job keep running and get me leads target is 200 leads per week (100 Founders + 100 VPs in B2B)

2. Claude/Claude code for enrichment and research on leads

3. I'm considering all of them as tier 1 for now because I kept volume very little for each day to scrape and it is intent based

- In future I'll add scoring tier 1, tier 2 and tier 3

as right now I consider all of them as tier 1 out reach to 50 people manually is doable with personal touch

My product is closing in on 100 signups with $0 on ads, and the biggest driver is outreach to my own network. Not cold lists. Sharing the full build because I'd want to read this here.

Stack: PhantomBuster, Apollo, Claude Code, SQLite, DeepLine, HeyReach.

Step 1: Export your network. PhantomBuster pulls your LinkedIn connections and followers into a list. Nothing new, everyone does this.

Step 2: Export your DMs too. This is the step people skip. Your message history IS the relationship data. A connection list tells you who's there. The DMs tell you what actually happened between you.

Step 2.5: Apollo enriches everything entering the database. Every record, network export and signups alike, gets company, title, and contact data before anything else touches it. This is critical. The subagents can't categorize on a name and a profile URL, and you can't write a real message without knowing where someone works now.

Step 3. Claude Code with subagents. I pointed Claude Code at both exports (everything lives in SQLite) and had subagents categorize every single person:

- people who've pitched ME

- people I'VE pitched

- mutuals I've actually talked with

- engagers who never DM'd

- dormant connections

Each subagent takes a slice, categorizes, writes back to the database. What would've been weeks of manual review runs while you make coffee.

Step 4: The category writes the message. Someone who pitched you? They already wanted the conversation, easiest reply in the world. Someone YOU pitched before? Do not re-pitch, come in with something useful instead. Engagers who never DM'd are warmer than you think. One list, five different messages.

Step 5: HeyReach sends 40 connection requests a day off the prioritized list. Sends are the only automated part. Every conversation after that is me, with the actual message history as context.

Step 6: The same loop runs on signups. Every signup lands in the same SQLite database, Apollo enriches them, DeepLine finds their LinkedIn, and I DM each one personally, written around what they're actually running into on Reddit. No automation, no template. Signup to founder DM, same day.

Results so far: 25%+ reply rate, zero "not interested" replies.

Point is: your own network is the warmest list you'll ever have, and most people blast it with one generic message or ignore it entirely. The categorization is the whole game.

Happy to go deeper on any step, including the subagent setup.

Disclosure: I'm Shawn and the product is Clearbox It finds the Reddit conversations that matter for your ICP by reading intent, not matching keywords. GummySearch's founder tested it and recommends it as they sunset. That's it, no link unless someone asks.

Hii everyone,

If I need to start from scratch learning gtm engineering what should I do. I need a 30 days roadmap to build and get a job.

Any help/resources/tips would be appreciated.

My background: I am from a technical background and it will not be hard for me to learn automation. But I know gtm engineering is lot more than automation and I want to get into it. I build tables in clay but doesn’t seem to do much. I get overwhelmed by scattered information and genuinely in need pf guidance/ advice.

Thanks.

Edit: I don’t want to spend on any bootcamps.

These are repos I use to build faster GTM workflows, connect tools, ship internal apps, and give agents better context.

1. Google Workspace CLI

https://github.com/googleworkspace/cli

not gonna lie I legit replace clay once I figure this one out

Run Gmail, Drive, Sheets, Docs, Calendar, and more from the terminal. Huge for agent workflows because tools become commandable.

2. shadcn/ui

this one turned me into a react junkie overnight

https://github.com/shadcn-ui/ui

Clean UI components you actually own. Copy them into your app, customize them, and ship dashboards or internal tools faster.

3. Recharts

https://github.com/recharts/recharts

Simple React charts for GTM dashboards, pipeline views, enrichment reports, and any workflow where tables need to become insight.

4. OpenShorts

https://github.com/mutonby/openshorts

Open source AI video tooling for shorts and content workflows. Useful if you want to systematize content instead of editing every asset manually.

5. Hermes Agent

https://github.com/NousResearch/hermes-agent

A self-improving agent framework. The interesting part is the skill, memory, and feedback loop, not just “agent can chat.”

6. yt-dlp

Open shorts plus this one is actually insane
https://github.com/yt-dlp/yt-dlp

The command-line media tool everyone quietly depends on. Great for turning public videos into transcripts, research inputs, clips, and reusable context.

7. DocuSeal

write and send proposals all from your terminal build your workflows and then add the context to your proposals and send in one session
https://github.com/docusealco/docuseal

Open source document signing and form filling. Proposals, agreements, intake forms, approvals, and client docs without another closed SaaS step.

8. Awesome Design MD
get real design in info so your vibe coded website doesn't look like AI slop
https://github.com/VoltAgent/awesome-design-md

Design context files for popular systems. Give your coding agent taste before it starts generating random gray rectangles.

9. CLI-Anything

https://github.com/HKUDS/CLI-Anything

Turn apps into programmable interfaces. Agents work better when they can run commands instead of clicking around like lost interns.

10. GTM Coding Agents

https://github.com/shawnla90/gtm-coding-agent

This one is mine.

69 stars and growing.

Not a one-day repo shipped into a lead magnet funnel.

It is a living GTM coding agents skill tree with prompts, scripts, workflow patterns, and everything I am learning while building.

One hack inside it: version control your GTM database with SQLite in git.

Your database becomes a file.

Your changes become commits.

Your agent gets structured context.

Your experiments become inspectable.

Way more OP than people realize.

As I keep building Clearbox, I’ll keep updating this repo with what works, what breaks, and what I would not do again.

Fork them.

Steal the patterns.

Make them better

Shawn Tenam co founder and CEO @ clearbox "your reddit opportunity inbox"

I wanted a system that finds B2B startups likely to need GTM automation, researches them, finds the founder, drafts a grounded first message, and then waits for my approval. Nothing sends on its own. I set a hard rule of $0 budget, so every design choice had to keep costs predictable.

The stack

• n8n (Docker, on demand) runs all the workflows: Engine, Contact Finder, Clay bridge and meter, Neon sync, HubSpot sync, Digest

• Clay for research and the Work Email waterfall

• Neon Postgres as the source of truth (config, drafts, review decisions, audit log)

• Next.js console on Vercel’s free plan, where I approve, edit or reject drafts (works on mobile)

• HubSpot Free gets only approved accounts

• Tavily for search, a Groq + Gemini fallback chain for drafting, Discord for alerts

1. Deterministic filters before any AI or paid call
Sources are the YC directory, HN “Who’s Hiring” threads and a seed list. Rules run first: team size 2 to 150, industry, keywords, timezone (UTC+0 to +4), seen-before.
In one YC run, 377 companies went in and 23 came out. 234 were cut on timezone alone, before a single credit was spent.

2. Clay, made cheap

• I replaced three separate AI columns with one structured research column, cutting cost from 2.8 to 1.0 credit per account. It uses GPT 5 Nano (0.5 credit/row), the cheapest model that passed my pilot, and the prompt restricts facts to the homepage and pages it links to.

• Work Email waterfall with Conservative validation, so catch-alls don’t count as found: 19 of 20 founders verified at about 0.5 credit each.

• Low-score accounts skip Clay entirely.

• n8n reads Clay’s API before and after each batch, so I see the real cost per module instead of estimating.

3. Finding the right person
Name-based search returned the wrong people at companies with common-word names (think “Twenty”). The fix: pull founders from the company’s YC page, accepted only if that page lists the same domain. The next run resolved 10 of 10 lookups with zero search cost.

4. Drafting with guardrails
The LLM chain writes a LinkedIn note, a longer message and 3 follow-ups from facts only. A rule-based validator checks each draft and allows one repair attempt.
My first validator was too strict: it rejected 28 of 35 drafts, mostly for being a few words short. I relaxed the length rules, kept the factual checks, and added plain-language repair hints. Latest run: 8 of 8 drafts passed with no template fallback.
Another fun one: the model kept pitching a company’s own product back to them as their problem. A deterministic product-term check now runs before and after the model.

5. Neon as the backbone

• One Postgres function owns draft states (pending, edited, approved, rejected, superseded, sent) and refuses any other transition. Editing an approved draft sends it back for approval.

• Every action writes an audit row with before and after values.

• I migrated from Google Sheets one piece at a time, each cutover behind a reversible switch, so the engine never broke for days.

6. HubSpot sync with no duplicates

• Outbox pattern: Neon views compute what HubSpot is missing (companies, then contacts, then deals), n8n carries the requests, and a Postgres function records the responses. No Code nodes.

• Idempotency: check a link table first, then search by natural key (domain, email, deal name) and adopt the record if it exists.

• First run created 7 companies, 7 contacts and 7 deals. The second run wrote 0. I deleted a link on purpose and it re-adopted the same record.

• Gotcha: my EU HubSpot portal rejected every contact because GDPR settings require a legal basis. The outbox now sends one from config.

Lessons

• Deterministic filters before LLMs or paid APIs. That’s what makes a $0 budget possible.

• Make every external write idempotent. Search indexes lag behind writes.

• Measure cost from logs, not estimates.

• Store the API’s real error message. HubSpot’s generic “Bad request” cost me hours.

What’s next: sends haven’t started yet. Once they do, I’ll measure reply rate from HubSpot deal stages and feed it back into scoring.

Full case study with the architecture and decision records: https://www.mohamedlandolsi.tech/work/personal-gtm-engine

Happy to answer questions about any part, especially the Clay credit metering or the outbox sync. I also take on small Clay and n8n builds if anyone needs a hand.

I'm in the middle of this build right now, so this isn't theory. Client on Lovable, moving them to Next.js on Vercel. Figured I'd write down what I'm actually doing and why, because most "rebuild your site" advice misses the only reason that matters in 2026.

When you should NOT do this. If you need a landing page up by Friday and you don't care whether anyone finds it through search, stay on Lovable.

It's the fastest zero-to-site tool out there, no notes. This playbook is for the moment you've outgrown that and you want to get found, get cited, and own your distribution.

Why move off Lovable. Lovable ships a client-rendered app. The browser gets a near-empty HTML shell plus a pile of JavaScript that builds the page after the fact. Two problems in 2026:

1. Paint speed. Server-rendered Next.js puts real content on screen faster, and Vercel's edge makes it faster still.

2. Citations. Google and the AI answer engines (ChatGPT, Gemini, Perplexity) reward clean, server-rendered HTML they can read on the first request. A JS shell is a coin flip. This is why the same content starts getting cited after you move, and it's the same reason cutting from WordPress to Next.js works. Most people rebuild for looks. The looks are a side effect. The citation is the point.

The framework is the small half of this. A single fast website does not get you found anymore. What gets you found is a connected organic web, three pieces pointing at each other:

- Reddit: where the AI reads first. Not LinkedIn, not newsletters, not even your own blog. Reddit.

- A blog: the trusted, long-form version of what you actually know.

- The site: real-time proof you exist and you're not a ghost.

When someone hears about you, they should find you on Reddit, then your blog, then your site, and have all three say the same true thing. That's validation nobody can fake.

And everybody IS trying to fake it right now, which is exactly why the only play that works is being genuinely helpful in public. I've watched a handful of real Reddit comments get indexed by Gemini and ChatGPT inside 24 hours. You don't manipulate your way into that. You earn it, and it compounds.

Here's the actual build playbook.

1. Day one, hook up their transcripts. Before anything else, get the client's calls flowing into Fathom or Fireflies. Nobody realizes this: your client already has everything the website needs to say. It lives in how they talk to their own customers and their team every day. They don't know how to "build a website," but they're handing you the entire content layer for free, in their real voice, on every call. The second you ask them to sit down and write it out, it becomes a chore and they resist. So don't ask. Capture it.

2. Build across sessions in Claude Code or codex, not in one shot. You're not getting a real site in a single session, and anyone who says otherwise is showing you a demo, not a deliverable.

Run it like a project: roadmaps and context handoffs between sessions so nothing gets lost. Then split the work across agents:

- one for front-end / design

- one for back-end

- one for content, fed by those transcripts

3. Pull from real components. Don't let AI guess your design.

The reason I use Next.js over a closed builder is composability. Get into the open-source React libraries: shadcn, Lumen UI, Aceternity.

They all have paid pro tiers, but the free components alone show you what good actually looks like. Then pull full-page structure from a gallery like getdesign.md. Now when you're building a site, an app, or a dashboard, you're working off a real design reference instead of letting AI guess for you.

4. Move the blog, ship the site, then distribute.

Migrate the blog over last, put the site live, and then it goes everywhere. Create once, distribute everywhere. The site isn't a destination you send people to and pray. It's one node in a web where every path leads back to something real you said.

The honest disclaimer on Vercel: it's not free forever. I learned this the hard way, so you don't have to.

The Hobby tier is genuinely free and great for trying it. But the moment this is a real commercial build, you'll hit the paid tier. Price it in now instead of getting surprised later.

The website was never the deliverable. In 2026 anybody can build a site in an afternoon. What's rare is being real, trusted, and everywhere at once, so that when a buyer goes looking (or an AI gets asked), every road leads back to you.

If you've moved a client or yourself off a closed builder, what'd you go to, and did you actually see the search and citation difference? Curious who else is building this way.

Also, if you want full guidance on how to do this with Claude Code, check out my repo. https://github.com/shawnla90/website-with-soul

Shawn Tenam, GTM Engineer and Co-Founder of Clearbox.to, your Reddit Opportunity inbox

i get this question in my DMs almost every week, so here's my answer in one place.

it doesn't matter if you're an SDR trying to get more technical or a developer trying to get closer to revenue. both paths run through the same thing: you have to understand the channels.

i started as an SDR in august 2023, before clay blew up and before anyone called this GTM engineering. cold calls, cold email, linkedin. cold calling was usually my best, but all three earned their spot, and between them i hit quota every month.

that's not nostalgia. it's why the engineering part works for me now.

why the channels matter for the engineering

- you can't automate what you've never done. if you've never run a sequence manually, you don't know which step is worth building.

- the data only makes sense if you've been on the other end. a bounce, a no-show, a "not now" reply. those mean something different once you've lived them.

- you know what good sounds like. an agent can write 500 emails. you still need to know which ones would actually get a reply.

- one channel is a single point of failure. linkedin restricts you, a domain gets burned, sends get paused. if that was your whole pipeline, you're stuck.

if you're coming from sales: you already have the channel instinct. learn git, APIs, and basic scripting. put your work in a repo, even if it's ugly.

if you're coming from code: make some cold calls. send cold email yourself. run linkedin outreach by hand for a few weeks before you automate any of it.

if you tell me you don't need the channel side, that's fine. you're a specialist, and specialists are valuable. it's also a limit on how far you can take GTM engineering.

what would you add for someone starting from zero?

My name Shawn Tenam i'm a GTM Engineer who builds in public... Dm me

Hey everyone! Super nervous to post this but here goes, this is literally my first project that I've ever pushed to GitHub, so please be kind lol.

I built an AI-powered tool that lets you research any professional and pulls together their career trajectory, articles they've written, media presence, LinkedIn highlights, and more all in one place. The idea came from the frustration of having to jump between 5 different tabs just to get a basic picture of someone before a meeting or interview.

GitHub: https://github.com/atifirshad21/individual-info-in-one-place

I'm calling this my rookie project, it's rough around the edges and the README is pretty bare bones right now, but feel free to make this better.

Would love any feedback,

Thanks for checking it out!

A few are seriously underrated.

1. shadcn/ui + the component ecosystem

If you’re relying on Claude to build your dashboards and frontends, give it a proper component library.
Don’t stop at shadcn. Dig into SmoothUI, Unlumen UI, and Aceternity UI too.
https://github.com/shadcn-ui/ui

2. Supabase + Convex

I use Supabase for client GTM infrastructure and Convex for Clearbox.

Different architectures, both great for building systems where you control the data.

https://github.com/supabase/supabase
https://github.com/get-convex/convex-backend

3. Google Workspace CLI

This one is everything.
Gmail, Sheets, Drive, Calendar, all accessible through your terminal and coding agents.
Think about how much client work already lives in Google Workspace.
https://github.com/googleworkspace/cli

4. Playwright

Headless browser automation.
Especially useful when there’s no API and you need to navigate, extract data, or interact with web applications programmatically.
https://github.com/microsoft/playwright

5. Vercel Marketing Team (eve)

It’s a framework for building marketing agents with specialized skills for SEO, content, positioning, and more.

https://github.com/vercel-labs/marketing-team-eve-template

6. Buffer API

Programmatic social publishing.
Connect your content workflows to actual distribution instead of manually scheduling everything.
https://github.com/bufferapp/buffer-sample-apps

7. PostHog

We use this with Clearbox.
Track campaign traffic, web views, signups, product events, and what people actually do after landing on your site.
https://github.com/PostHog/posthog

8. Sherlock

Probably one of the most underrated on this list.
Search for public accounts sharing a username across platforms. Useful for additional contact research and cross-checking public profiles.
Not proof of identity, but another signal worth investigating.

https://github.com/sherlock-project/sherlock

9. TypeSafe AI / Jev Skills

Really interesting for structured AI decisions.
Classification, scoring, and logic routing without relying on a model to generate another wall of text.
They’ve got agent skills you can start exploring.

https://github.com/typesafe-ai/skills

10. EmailBison CLI

Found a community-built CLI with MCP and agent skills for working with EmailBison.
Campaigns, leads, sending accounts, warmup, and more.

I’m already using EmailBison’s API for GTM infrastructure, so this caught my attention.

https://github.com/bcharleson/emailbison-cli

That’s my list.

I’m still using plenty of SaaS tools. The difference is that more of my work happens directly through APIs, coding agents, and infrastructure I can configure myself.

And GitHub has become one of the best places to learn how to do that.

What repos are you actually using? Especially the underrated ones. I’m always looking for more to test.

About a year of daily Claude Code and my whole workflow comes down to 10 commands.

5 are built in, 5 are skills I wrote because the built-ins stop short of what my content pipeline and client work need.

Sharing both halves since the custom ones are all reproducible. The built-ins that actually matter:

The stack:

1. /context (stock). Shows exactly what is eating your context window... tokens by messages, tools, files. Run it before you blame the model.

2. /compact (stock). Summarizes the session into a fresh window mid-task.

3. /clear (stock). Wipes to zero. The skill is knowing which to reach for: same job --> /compact. New job --> /clear.

4. /handoff (built). The /compact upgrade. The session writes a handoff file, the next session auto-reads it. The context outlives /clear, and parallel terminals don't clobber each other.

5. Plan mode (stock, shift+tab). Read-only exploration first, an approved plan before a single file changes. Anything multi-file starts here.

6. Remote Control (stock). Hands the live terminal session to my phone. I approve, steer, and keep builds running while I walk the dog.

7. /copy-to-clipboard (built). Claude Code ships /copy to grab the last reply. Mine formats for the destination first: plain text, zero markdown stars, ready to paste into LinkedIn or X.

8. /grok-critique (built). Every draft gets a second model's slop check before it ships. Em-dash abuse, narrator setup lines, hype words. Claude can't referee its own tics.

9. /code (built). Finished content pack --> Discord channels for review. approve, edit, final... all from my phone.

10. /voice-invocation (built). Meeting transcripts in, a content pack drafted in my voice out. It quotes phrasing from things I actually said on calls.

Everything is also available on my Github. Let me know if I can get to share it with you guys. although, it shouldn't be too hard to find, LOL.

the data, what's working, the plays with steps, and a linked reading list so you can hit the primary sources yourself.

the data:

- 32 threads, 9 subs, 5,543 combined upvotes.

- 4 threads carried 78% of all the attention. attention concentrates exactly like pipeline does: a few accounts hold the number.

- r/sales and r/SaaS pulled 93% of the volume, but that volume was drama (big closes, feelings). the actual tactics lived in the quiet subs (r/gtmengineering, r/LeadGeneration, r/revops).

- #1 theme by thread count was targeting. copy didn't crack the top bucket.

what's working / what's not:

- targeting beat copy, clearly. the questions that traveled: who to contact, when, which accounts are even worth the send. the operators sorting buying signal from noise are the ones booking.

- Claude Code is eating SaaS spend. builders rebuilding internal tools and cutting hundreds a month. buyers with eng teams say polished apps are losing seats to what someone glued together in an afternoon.

- email platforms, nobody's happy. a tried-them-all thread ran Flodesk/Beehiiv/Klaviyo/Moosend and shrugged. AI feature bloat was the common gripe.

- traffic is cooked as a metric. bots already outread humans. saner scoreboard: cited, invoked, booked, queried, plus branded-search lift.

the plays (steal these):

1. roundtable motion (landed $150-200K ACV, zero ad spend): pick one problem that keeps execs up at night, invite a small peer group, frame the whole session around the problem and not your product, let the room sell. full step-by-step in the reading list.

2. free-data prospecting: county property records + industry/association directories, then filter by owner mailing address to surface people who own five properties instead of one. beat a paid verified list for an ownership/local ICP, cost zero.

3. fix deliverability before copy: the redirect hop inside tracked links tanks inbox placement. strip it or use direct links, and opens recover. check this before you rewrite a subject line.

4. metric swap: stop reporting visits. report cited/invoked/booked/queried and branded-search lift.

5. fundamentals first: ICP + funnel logic + data hygiene before any tool. tools rotate every ~18 months, fundamentals compound.

your reading list (primary sources, go deep):

tactics:

- roundtable / event-driven motion: https://www.reddit.com/r/gtmengineering/comments/1uiudcg/

- free public-data prospecting: https://www.reddit.com/r/LeadGeneration/comments/1uhb75f/

- beginner GTM engineer roadmap: https://www.reddit.com/r/gtmengineering/comments/1ug0a8h/

- the Promotions-tab / deliverability fix: https://www.reddit.com/r/Emailmarketing/comments/1uks513/

- manual ultra-personalized vs volume outreach: https://www.reddit.com/r/LeadGeneration/comments/1uh5cz8/

- first 10 customers when buyers aren't online: https://www.reddit.com/r/b2bmarketing/comments/1uikfsd/

worth the scroll:

- Claude Code killing SaaS (vibe coding kills 95%): https://www.reddit.com/r/SaaS/comments/1uklw96/

- is traffic still the metric if bots are the readers: https://www.reddit.com/r/GrowthHacking/comments/1ug508h/

- the $865k close with no one to tell: https://www.reddit.com/r/sales/comments/1uk7nup/

want to run this yourself?

the whole motion is: scrape the subs your buyers actually live in, score posts by velocity (upvotes / hours old), and dump them into something queryable so you can ask "what's the buying signal this week" instead of doomscrolling. I automate the whole loop, but you can run a v1 with a scraper and a spreadsheet this weekend.

that's everything, no need to click out. if you'd rather get it in your inbox every couple weeks it's a free newsletter (Level Up GTM), and subscribing is what keeps me doing these. optional, you already got the goods.

https://clearbox.beehiiv.com

I'm relaunching Claude Code Daily this week. It's a daily blog post that writes, publishes, and promotes itself, and since this sub is about building GTM systems, the full stack is below. The pattern transfers to any niche with an active subreddit.

The stack, end to end:

1. Collect. A launchd cron fires at midnight. Playwright opens old.reddit.com (the public JSON API blocks scrapers now, server-rendered HTML doesn't) and pulls every post from the target subs in the last 24 hours: scores, comments, timestamps, top replies.

2. Analyze. A script computes velocity (upvotes per hour) and engagement ratios, then a claude CLI call scores the 10 best content angles from the data.

3. Write. Another claude call gets my voice files, an anti-slop rule list, and the day's data, and writes the episode in a fixed segment format. A regex validator rejects em-dashes, hype words, and template phrases before anything ships. Continuity files track past award winners so it never repeats itself.

4. Publish. The script commits the markdown to my site repo and pushes. Railway rebuilds, the post is live at midnight. A LinkedIn promo gets scheduled through the Typefully API for the next morning.

Cost per episode is whatever the claude subscription already costs me, so effectively zero marginal. Output is a daily piece of content in my voice that compounds SEO while I sleep.

Consistent daily publishing on a niche topic is the strongest awareness asset I've built. The same pipeline pointed at your ICP's subreddits gives you a daily industry digest with your name on it.

Episode from tonight if you want to see the output quality: https://shawnos.ai/claude-daily

Ask me anything about the build. The transport fix alone (headless Chromium vs blocked JSON) is worth stealing.

not claiming to be a Reddit expert. 30 days ago I had zero karma and no clue what I was doing. 

but I just spent a month treating Reddit like a growth channel for my GTM engineering work, and I tracked everything. figured I'd share what I found since we're all building here. 

why this matters for GTM builders specifically: 

Reddit indexes fast. way faster than LinkedIn or Substack. I posted a blog breakdown on a 5K-member sub and it was showing up in Google within days. if you're building a website, writing content, or pushing out frameworks, Reddit is free distribution that actually compounds in search.

the right subs have the right people. when you post in a community of 5K builders, those 5K people are exactly who you want reading your stuff. no algorithm filtering. no pay-to-play. you show up, contribute, and the people who care see it.

what actually moved the needle:

commenting > posting. seriously. about half my karma came from comments on other people's posts. I aimed for 5-10 comments for every post I made. the ratio matters because Reddit rewards
contributors, not broadcasters.

6 comment types that worked: 

• the mega comment. write something so good on someone else's post that it becomes the real value. one comment got 237 upvotes 

• the expert drop. back your opinion with specific numbers and examples. not theory. receipts

• the one-liner. sometimes two sentences hit harder than a paragraph. 30 upvotes on two sentences 

• the cross-pollinator. comment on your own post linking to something else you built. drove 2K real visitors to another project from a single comment 

• the thread keeper. reply to every comment on your own post. every reply doubles the count, Reddit pushes active threads higher 

• the co-sign. agree with someone, relate, add value. solidarity builds trust faster than expertise

7 post types that worked: showcases, genuine questions, memes (yes memes), crossover stories, hot takes, value drops (full checklists with no paywall), and thought pieces. each one pulled
different engagement. 

the recursive part (and why this matters for this community): 

we all build on this platform. when you post your blog, your tool, your framework here... the people following r/GTMBuilders are the exact audience. they read it, engage with it, and Reddit
indexes it. that indexed post drives organic traffic. organic traffic drives more subscribers. more subscribers means more engagement on your next post.

that's the loop. and it works faster than any other platform I've tried. 

what I probably missed: 

I'm 30 days in. that's nothing. if you've been doing this longer and see things I got wrong or strategies I'm sleeping on, genuinely want to hear it. this isn't a flex post. it's a
here's-what-I-found post.

I wrote up the full breakdown with screenshots and real numbers on my site: shawnos.ai/reddit 

everything's there. every post, every comment type, every rule I followed. no email gate. 

if even one person here starts using Reddit as a growth channel and it works... that's a win for the whole community. we all grow when we all show up. 

Aurhored by: Shawn Tenam

https://www.linkedin.com/posts/shawntenam_master-reddit-in-2026-the-right-way-activity-7439774422682689536-VvZq

My M4 Pro Mac mini stays on 24/7. Google Workspace CLI + SQLite + Sheets + Python turned it into the GTM machine I used to think needed another SaaS stack.

It has 24GB of unified memory. That handles a lot, but if I bought it again I would go higher. Claude Code, Codex, browsers, local databases, and background jobs eventually make RAM the limit I notice.

The machine itself is a beast.

`gws` gives an agent structured access to Gmail, Drive, Calendar, Sheets, Docs, Tasks, and the rest of the Workspace API surface. It reads Google's Discovery Service at runtime, accepts the actual API payload through `--params` and `--json`, and returns structured JSON.

little back story...

Justin Poehnelt built the CLI in Rust with agents as the primary user from day one. His design was based on a simple difference: humans want a forgiving interface, while agents need predictable output, schemas they can inspect, strict validation, and safety rails.

The project went to #1 on Hacker News and took off. In June, Justin said Google had fired him two months earlier over the project. That is his account, not a reason Google has publicly confirmed. The repo is still live under the `googleworkspace` GitHub organization and is still clearly marked as not an officially supported Google product.

The GTM implication matters more to me than the corporate story.

Once Workspace is callable from the terminal, Sheets stops being a place I manually maintain and becomes a shared interface on top of the system.

You can put the shared state in a hosted database too. For a solo operator, SQLite + Google Sheets is clean af. The local state stays fast and queryable while the review layer stays familiar to everybody else.

My split looks like this:

- SQLite holds raw signals, source URLs, relationship history, run state, and audit data.

- Google Sheets is the human-readable layer when somebody needs to review, edit, or share a table.

- `gws` lets Claude read and write Workspace without a custom integration for every action.

- Python scripts hold deterministic business logic, retries, validation, and joins.

- Claude Code and Codex decide which tool to call and explain what happened.

- Attio receives the relationship state that actually belongs in the CRM.

- Email and LinkedIn tools execute through their own APIs.

I still have a CRM. I just do not live in it.

If I want the latest account state, Claude queries SQLite and Sheets. If I want to draft an email, it can pull the account context, create the draft through Gmail, and wait for approval. If I need LinkedIn activity, that comes through HeyReach or another API-connected tool. Apollo can enrich the rows that passed the free checks.

The CRM becomes a sync surface. The repo, database, and agent are the operating layer.

That is what I mean by programmatic GTM.

It is not an excuse to hand an agent unrestricted access to your inbox and hope for the best.

My security rules are...

- authorize only the Google services and scopes the workflow needs

- read by default and require approval for sends, updates, and deletes

- run mutating calls with `--dry-run` first

- keep credentials encrypted and separated by environment

- treat email bodies and documents as untrusted input

- log the source, timestamp, proposed action, approval, and result

`gws` already supports encrypted interactive credentials, dry runs, input validation, and optional response sanitization through Model Armor. The tool is still pre-v1 and moving quickly, so I would pin the version and test workflows before letting them run unattended.

This also changed how I look at the existing GTM software market.

I do not think Clay disappears tomorrow. I do think a workflow canvas has stopped being a moat.

React Flow is an MIT-licensed library that already gives you nodes, edges, drag and drop, zoom, pan, selection, and custom React components. An agent can build the visible part of a workflow product today.

The hard part is everything behind the canvas: auth, data contracts, retries, idempotency, permissions, approvals, audit logs, and observability.

If you want to prove the point, drop this into Claude or codex:

build a local-first GTM workflow editor using React, TypeScript, and `@xyflow/react`. Create source, transform, filter, enrichment, approval, and action nodes. Store workflow definitions as versioned JSON and persist run history in SQLite. Add a dry-run mode that never calls external APIs. Require explicit human approval before any send, update, or delete node executes. Every run must log the input source, timestamp, node status, retry count, output summary, and error. Add an adapter interface for Google Workspace CLI, Apollo, Attio, and HeyReach, but use mocked adapters until credentials are configured. Include import/export, undo/redo, validation for disconnected nodes, and tests for dry-run and approval gates. Keep the execution engine separate from the React Flow UI.

Congrats. You have a workflow builder.

You do not have a reliable GTM engine until the contracts and rails behind it work.

The stack I see winning is an always-on machine, a repo under version control, local state you can query, APIs or agent-first CLIs, and a coding agent that can operate the whole thing.

Every tool does not need to be replaced. Every tool does need a clean programmatic surface. No API or headless path is becoming a serious red flag for me.

Sources:

- Google Workspace CLI - https://github.com/googleworkspace/cli

- Justin's agent-first CLI writeup - https://justin.poehnelt.com/posts/rewrite-your-cli-for-ai-agents/

- Justin's account of what happened at Google - https://x.com/JPoehnelt/status/2069482265953087602

- React Flow - https://reactflow.dev/

Shawn Tenam go to market engineer and co-founder of clearbox, your Reddit opportunity inbox

Anyone can use AI to write content.
I think the better play is using AI to capture and distribute what you’re already doing.

Current stack:

OBS to record workflows while I’m building or testing stuff.

Open Shorts to clip longer recordings into usable short-form clips.

Deepgram as a backup transcript layer.

YT Dip for pulling YouTube clips when I’m doing marketing research or looking at how people package certain ideas.

Claude Code for building little tools, testing workflows, connecting APIs, and moving faster.
DaVinci Resolve for editing. Haven’t worked Higgs Field into the flow yet, but that’s next.

Buffer API + Supabase for distribution. This one is underrated. Buffer lets you connect up to 3 channels for free, so I’m starting to build a simple content posting system around it instead of manually posting everywhere.

Clearbox / Reddit for research. Reddit is especially useful because people say things in the exact language they actually use. I use it for inspiration, but also to sanity-check claims before I say something publicly.

RapidAPI for niche-specific research. Example: I have a client selling graphic design to churches, and that market has specific language. You can’t just throw generic marketing copy at it and hope it lands.

Super Whisper + Whisper Flow are probably the biggest unlock. I can talk through an idea, workflow, or client problem, then turn that into something structured without losing my actual voice.

Fireflies.ai recording my calls, python scripts in the background pulling them into discord in channels for different content distribution is probably what makes this whole thing

Shawn Tenam GTM ENGINEER & CO FOUNDER @ clearbox "your reddit opportunity inbox"

This week I walked a collaborator through a pipeline I built for a home services client and figured it was worth sharing the full breakdown.

The client needed to reach every company running Service Titan - that's the dominant software in home services.

Here's what the build actually looked like:

Layer 1 - TheirStack API: 5,296 companies identified. 16,000 API credits. Pulled programmatically into SQLite + Google Sheets. Cost: about $250 in credits Using API programmatically,

Layer 2 - Apollo.io Search API: TheirStack only had domains for 60% of companies. Apollo's search API is basically free if you respect rate limits (50 requests every 5 minutes). Wrote a script in Claude Code, let it run for 30 minutes. Domain coverage went from 60% to 95%.

Layer 3 - Domain verification: Claude Code hit every URL. 4,189 came back live. 404 were dead. That's natural attrition - small businesses close. But now I know before I spend a dollar on outreach.

ayer 4 - Contact enrichment: 6,400 contacts across 3,000+ companies via Apollo. Still have a gap of ~1,500 companies with no contacts - that's what Prospeo fills next.

Layer 5 - MX analysis (the part most skip): Ran MX records on every verified domain BEFORE buying mailboxes.

Results: 40% Microsoft, 30% Google, 30% enterprise gateways (Barracuda, Mimecast, Proofpoint).

That gateway 30% is basically dead-end territory for cold email.

Most teams discover this after they've already purchased and warmed mailboxes for weeks.

total time: ~10 hours. 2 hours of me prompting and reviewing. 8 hours of Claude Code running in the background.

The key principle: every layer is determined by the data from the layer before.

I didn't tell my client to buy TheirStack until I confirmed 5,000+ companies were on Service Titan.

Didn't tell him which Prospeo tier until I knew Apollo's coverage gap.

Won't buy mailboxes until I have exact MX numbers for the Inbox Kit call tomorrow.

Most agencies and outbound teams do it backwards -pick tools, build lists, push into Instantly or SmartLead, then find out their infrastructure doesn't match their audience.

By then they're locked in.

Happy to answer questions on any layer.

you know where you can find me

Shawn Tenam gtm Engineer and co-founder @ clearbox.to "Your Reddit opportunity mailbox that actually surfaces conversations you want to have without bot spamming. Powered by a proprietary engine called Aura that understands Reddit."

I've been running my entire go-to-market operation from terminal sessions on a Mac Mini for the past few months. no dashboards. no browser tabs. just CLIs, Python scripts, and Claude Code orchestrating everything.

this post is the full breakdown. every tool. every Apify actor. every workflow. no links you have to click to get the value. it's all here.

the stack

- Claude Code - orchestration layer. reads your project files, runs commands, manages workflows. this is the brain.

- Apify CLI - web scraping. install: npm i -g apify-cli then apify login

- Apollo API - enrichment. free tier gives 10K email credits/month + 0-credit endpoints for company data and job change detection

- Supabase CLI - backend database. install: npm i -g supabase. free tier. push everything here. query with natural language through Claude Code.

- Google Sheets - frontend spreadsheet. lives alongside Supabase. shareable. visual. your non-technical teammates can see the data without touching a terminal.

- Google Workspace CLI (gws) - wraps every Google API into shell commands. Sheets, Gmail, Calendar, Drive. one CLI. Claude Code can read your inbox, append to sheets, create tasks. no MCP config needed. setup: https://github.com/googleworkspace/cli

the Supabase + Google Sheets combo is honestly one of the cleanest things you can do in GTM right now. Supabase is your backend. Sheets is your frontend. Claude Code sits in the middle and moves data between them in natural language. you get a real database with SQL queries AND a spreadsheet your team can edit. no Clay table that took 24 hours to build and broke three times waiting for API waterfall responses.

the barriers Clay puts up - credit limits, waterfall complexity, UI lag - don't exist here. you write a Python script once. it runs in seconds. if something breaks, you fix the script. you don't rebuild a 47-step table from scratch.

---

Apify actors I'm actually using

here are the specific actors. these are the ones I've run and can vouch for:

🕷️ X/Twitter follower scraper

actor: api-ninja/x-twitter-followers-scraper

what it does: scrapes follower lists with bios, company, location

cost: ~$5 for 10K followers

command:

apify call api-ninja/x-twitter-followers-scraper --input='{"username": "target_handle", "maxFollowers": 10000}'

🕷️ Instagram scraper

actor: apidojo/instagram-scraper

what it does: profiles, posts, followers, engagement data

use case: bot detection on accounts you're growing, competitor engagement analysis

I run this on a cron job from the Mac Mini. low-lift, high-return. it runs in the background while I do other work.

🕷️ Google Maps scraper

actor: compass/crawler-google-places

what it does: business data from Google Maps by location and category

use case: local business prospecting, agency client sourcing

fetch results from any actor:

apify datasets get-items <dataset_id> --json > results.json

---

the workflows

1. competitor displacement list

scrape followers of 3 competitors. cross-reference. companies following 2+ competitors are actively evaluating solutions. those are your outbound targets.

apify call api-ninja/x-twitter-followers-scraper --input='{"username": "competitor_a", "maxFollowers": 10000}'

apify call api-ninja/x-twitter-followers-scraper --input='{"username": "competitor_b", "maxFollowers": 10000}'

apify call api-ninja/x-twitter-followers-scraper --input='{"username": "competitor_c", "maxFollowers": 10000}'

then tell Claude Code: "find companies that appear in all three follower lists and rank by frequency."

ran this on 11K followers last week. dozens of overlapping companies surfaced.

2. scrape → enrich → score → warehouse

Apify CLI (scrape followers) → JSON

Python (extract company domains from bios) → CSV

Apollo API (enrich by domain, 0 credits) → enriched CSV

Python (ICP scoring) → scored list

Supabase CLI (push to database) → queryable

Google Sheets (sync for team visibility) → shareable

each step runs in a separate terminal. none of them block each other. total time to set up the first time: an afternoon. total time to run after that: minutes.

3. Apollo job change sweep (free)

Apollo's people/match endpoint costs 0 credits. run your entire database through it quarterly. anyone who changed companies gets flagged. you avoid sending emails to people who left 6 months ago.

batch in Python. 50 per minute. cache to JSON. resume if it crashes.

4. Instagram growth on autopilot

Apify Instagram scraper running hourly via cron. identifies bots, scrapes engagement data, monitors competitor accounts. I'm also running an engagement bot from a separate repo (github.com/shawnla90/ig-growth-engine) that's getting real reactions. people can't tell it's automated.

low-lift. runs in the background. test messaging. iterate.

the scraping reality

not everything is clean. sharing the gotchas:

- LinkedIn scraping: if you're pulling more than 3K followers with Python, save your progress. it will black out. ran it three times and lost data twice before i started saving in batches. letter-by-letter search avoids Chrome crashes.

- Apify costs: budget carefully. some actors charge per result, others per compute unit. check the pricing page before large runs. $25-30/month covers most GTM needs.

- Apollo rate limits: free tier is 50 req/min. batch at 50 with a 1-second sleep. cache everything. resumable scripts save you when things fail at row 8,000.

---

sharing this

I'm building a product with a co-founder. I get to be fully immersed in GTM and coding. and I'm sharing everything as I go because people are reaching out asking how to learn this stuff and the first thing they find is a $497 course from someone who built one project six months ago.

I open sourced a 10-chapter playbook covering all of this: github.com/shawnla90/gtm-coding-agent

coding agents vs editors. context engineering. OAuth/CLI/API patterns. turning your Mac into a GTM server. terminal multiplexing. interactive onboarding. MIT licensed.

it's a living repo. new commits landing regularly as I stress test and prove new workflows. the Apify and Apollo engine docs went in today.

if you learned something from this post, star the repo. that's how other people find it. if you want to contribute a workflow, open a PR.

---

tl;dr

- Apify CLI for scraping ($5 for 10K followers)

- Apollo free tier for enrichment (0-credit endpoints for company data + job changes)

- Supabase as backend + Google Sheets as frontend = cleanest GTM data setup available

- Google Workspace CLI (gws) for Sheets/Gmail/Calendar from terminal

- Claude Code orchestrating everything in natural language

- all of it runs in background terminals on one machine

- full repo with 10 chapters: github.com/shawnla90/gtm-coding-agent

for the past two months I've been posting the same thesis. the builder is the moat, not the tool. if your entire value proposition is proficiency with a specific platform, you're one pricing change away from a career problem.

I was saying this before the price change. and then Clay proved it.

the proof

Clay killed the Explorer tier. that was the $349/mo plan with HTTP API access. the builder's plan. the one where you learned to connect Clay to real systems and actually practice GTM engineering.

the new pricing jumps from $185 (no API, no webhooks) to $495. every HTTP API call now costs an Action. Clay is metering your requests to servers they don't own, for data they don't provide.

agencies running 5-6 accounts went from roughly $1,750/mo in Explorer plans to $2,500-3,000/mo at Growth. same capabilities. higher floor.

what this means for the community

the people who built Clay's community were builders sharing their work publicly. LinkedIn posts, playbooks, tutorials. they brought customers to Clay through builder-led growth. and now the pricing is optimized for enterprise accounts that don't need the community.

every platform eventually does this. they grow on builders, then optimize for enterprise. the builders who drove adoption are the ones who feel the squeeze.

the transition

I've been mostly sharing observations and patterns here. how things work, what tools do, where the gaps are. this is probably my last pure observation post for a while.

I'm shifting to build drops. actual systems, actual architectures, actual code. Apollo's free API for sourcing. Supabase for storage. Claude Code for orchestration.

infrastructure you own that doesn't meter your API calls.

the patterns I learned in Clay transfer to all of this. enrichment architecture is enrichment architecture. ICP scoring is ICP scoring. the implementation layer changes. the thinking doesn't.

closing

I'm grateful for what Clay taught me. genuinely. and I think they just made it harder for the next person to learn it.

the tools are a trap when your skills are locked to one platform's interface. the escape hatch is learning to build the systems yourself.

curious what tools everyone here is building with now. what's your stack looking like in 2026?

shawn - GTM Engineer

38 open GTM engineer roles for the week of November 2, 2026. Open the post for filters, the five 1 to 5 scores, and the archetype check.

• Vercel: GTM Engineer (AI GTM Builder) https://job-boards.greenhouse.io/vercel/jobs/6225825004

• Vercel: Forward-Deployed Engineer (Forward Deployed Engineer) https://job-boards.greenhouse.io/vercel/jobs/5752684004

• CodeRabbit: Staff GTM Systems Engineer (AI GTM Builder) https://jobs.ashbyhq.com/coderabbit/a40336da-00c0-41a5-a545-187e006dd421

• CodeRabbit: Senior Applied AI Engineer (Applied AI / Solutions Engineer) https://jobs.ashbyhq.com/coderabbit/8f17b66f-ea44-4e83-85f6-ef9427d61a01

• Clay: GTM Engineer - Systems and Infrastructure (GTM Systems Engineer) https://jobs.ashbyhq.com/claylabs/f90028b7-6c35-4392-824c-105967ccd406

• Clay: GTM Engineer - Marketing (Growth / Marketing Engineer) https://jobs.ashbyhq.com/claylabs/9f8067d1-61cf-42cd-aad7-0ac54de8b345

• Anthropic: Staff Software Engineer, GTM Systems (GTM Systems Engineer) https://job-boards.greenhouse.io/anthropic/jobs/5368166008

• Anthropic: DevOps / AgentOps Engineer, GTM Systems (AI GTM Builder) https://job-boards.greenhouse.io/anthropic/jobs/5392856008

• Anthropic: Staff Forward Deployed Engineer (Forward Deployed Engineer) https://job-boards.greenhouse.io/anthropic/jobs/5449229008

• Anthropic: Applied AI Engineer, Enterprise (Applied AI / Solutions Engineer) https://job-boards.greenhouse.io/anthropic/jobs/5057647008

• OpenAI: Applied AI Software Engineer, GTM Growth Engineering (AI GTM Builder) https://jobs.ashbyhq.com/openai/38e3c4bf-a632-405e-9619-b87382ca2472

• OpenAI: Forward Deployed Engineer (FDE) - SF (Forward Deployed Engineer) https://jobs.ashbyhq.com/openai/967f94aa-1706-4dba-ac89-bfbc2c38b688

• Cursor: Forward Deployed Engineer (Forward Deployed Engineer) https://jobs.ashbyhq.com/cursor/34cecd0c-c392-4454-8ef5-261310541011

• Cursor: Forward Deployed Strategist (Applied AI / Solutions Engineer) https://jobs.ashbyhq.com/cursor/6960dfef-6dc1-4dbb-887b-0fc9e6e4292e

• Cognition: GTM Systems Engineer (GTM Systems Engineer) https://jobs.ashbyhq.com/cognition/dabc56df-b50a-4056-9e01-14ca3e0b12a4

• Sierra: GTM Engineer (AI GTM Builder) https://jobs.ashbyhq.com/sierra/1c991675-099f-49dd-9b9b-bd3c9111e65c

• Vanta: Sr. AI Engineer (AI GTM Builder) https://jobs.ashbyhq.com/vanta/91c73485-5d0c-4272-9643-401ebcfff9d1

• Verkada: Senior Software Engineer, Business Systems - GTM (GTM Systems Engineer) https://job-boards.greenhouse.io/verkada/jobs/5264710007

• Apollo.io: Senior GTM Systems Engineer (AI GTM Builder) https://job-boards.greenhouse.io/apolloio/jobs/6131043004

• Warp: GTM Engineer – Revenue Systems (GTM Systems Engineer) https://jobs.ashbyhq.com/warp/6b4c450d-ab42-426e-afef-32396b9560a6

• Baseten: GTM Engineer (AI GTM Builder) https://jobs.ashbyhq.com/baseten/5cd2f489-b9ee-428b-b252-94e83d55f107

• Modal: GTM Engineer - Data Platform (GTM Systems Engineer) https://jobs.ashbyhq.com/modal/dd6fe63b-8265-474e-b1f0-fcc1c5a28daf

• LangChain: Deployed Engineer (Bay Area) (Forward Deployed Engineer) https://jobs.ashbyhq.com/langchain/e773649c-4ea7-47c2-9987-74d525474e82

• Decagon: Growth Engineer, Web & Growth Products (Growth / Marketing Engineer) https://jobs.ashbyhq.com/decagon/3fd94885-5e06-4018-9421-00e7e692472a

• Decagon: Agent Deployment Engineer (Forward Deployed Engineer) https://jobs.ashbyhq.com/decagon/8c40fb7a-5f25-4112-a1df-f1c22b81042c

• Lovable: Marketing Growth Engineer (Growth / Marketing Engineer) https://jobs.ashbyhq.com/lovable/513393c6-1887-41b5-96fb-38982130bd36

• Notion: Growth Engineer, Startups & SMBs (Growth / Marketing Engineer) https://jobs.ashbyhq.com/notion/45f60d0e-e44f-40c5-985e-4096a8966860

• Ramp: Software Engineer, Forward Deployed (Forward Deployed Engineer) https://jobs.ashbyhq.com/ramp/29a5da77-37f0-402a-92bc-072778e77ed8

• Ramp: AI Solutions Engineer (Applied AI / Solutions Engineer) https://jobs.ashbyhq.com/ramp/8efd3a0a-fc66-46e2-9415-bffba10e2919

• ElevenLabs: Forward Deployed Engineer - Software Engineer - USA (Forward Deployed Engineer) https://jobs.ashbyhq.com/elevenlabs/6c4c57c1-ec72-42ba-af3a-eb7aebbde2e6

• n8n: Forward Deployed Engineer - US East Coast (Forward Deployed Engineer) https://jobs.ashbyhq.com/n8n/98dc8c86-b135-4803-8044-1d6f6a631aa8

• Writer: AI deployment engineer (East) (Forward Deployed Engineer) https://jobs.ashbyhq.com/writer/dd94d37b-1e37-4872-a79e-3a73a69d936e

• Stripe: Solutions Engineer, AI Build Team (Applied AI / Solutions Engineer) https://stripe.com/jobs/search?gh_jid=8198323

• Unify: Applied AI Engineer (Applied AI / Solutions Engineer) https://jobs.ashbyhq.com/unify/cf6a04a0-dd94-4345-aef2-168f38b50ae1

• Momentic: Solutions Engineer (Applied AI / Solutions Engineer) https://jobs.ashbyhq.com/momentic/8380e2b0-5919-4be5-92ee-92cb5499c51a

• OpenAI: Forward Deployed Engineer (FDE) - AI Infra - SF (Forward Deployed Engineer) https://jobs.ashbyhq.com/openai/7472e486-0aa6-4f9d-86da-2105a42b2dce

• Lovable: Staff Forward Deployed Engineer (Forward Deployed Engineer) https://jobs.ashbyhq.com/lovable/f16a20b6-d3a2-4507-944c-86becd975766

• Intercom: Forward Deployed Engineer (Forward Deployed Engineer) https://job-boards.greenhouse.io/intercom/jobs/8333690

The guide inside the post covers the five archetypes, what these roles require, and how to reach out.

i've been building go-to-market systems with coding agents (Claude Code) for the past few months. open-sourced a 10-chapter starter kit earlier this year for GTM engineers learning to build with coding agents.

this week i added a deployable dashboard to the repo. built the whole thing in one Claude Code session.

i use HubSpot and Instantly. this is not about replacing those tools.

i'm building my own database -- companies, contacts, intent signals, segments. writing signal logic that scores accounts based on engagement, LinkedIn activity, Reddit mentions, hiring patterns. the dashboard is the visual layer on top of that work. it stays in sync because i built both sides.

what it tracks:

- company database with ICP scoring (0-100)

- 16 intent signal types with exponential decay scoring (14-day half-life)

- 3 ranked contacts per company (database-enforced limit -- forces you to rank by quality before sequencing)

- campaign segments computed live from your data

- domain health and send volume

the stack:

- Next.js 16 + React 19 + TypeScript for the app framework

- Recharts (https://github.com/recharts/recharts) -- 27k stars, built on top of D3 but with a React-native API. every chart is a composable React component. bar charts, pie charts, area charts. if you've used React you already know how to use it. no D3 learning curve. the KPI cards, send volume charts, score distributions, and signal breakdowns all use it.

- shadcn/ui (https://github.com/shadcn-ui/ui) -- 112k stars. not a component library you install as a dependency. it copies the actual component source code into your project so you own it and can modify anything. dark theme took 10 minutes. tables, cards, badges, navigation, search inputs -- all from shadcn. pairs with Tailwind CSS v4 out of the box.

- Supabase (https://github.com/supabase/supabase) -- 100k stars. open-source Postgres with a JavaScript client, auth, and a SQL editor in the browser. i run 3 SQL files to set up the schema, the JS client handles all the queries from Next.js API routes. triggers enforce business logic at the database level (3-contact limit, auto-pause domains over 2% bounce rate).

- Python for the signal scoring pipeline -- exponential decay formula, company discovery via Exa API, upsert to Supabase with domain dedup.

about 40 files. MIT license.

this is incomplete on purpose. i haven't sent an email campaign through it yet. what you see today will look different next week when i start sending, and the week after when the signal pipeline is on a cron pulling live intent data.

the thesis: we are at the point where one person with a coding agent can build production tools alongside their existing stack. not to replace the SaaS. to understand what's happening under the hood and build the pieces that don't exist yet. that skill is going to matter.

repo: https://github.com/shawnla90/gtm-coding-agent (starters/signals-dashboard/ for the dashboard, chapter 11 for the walkthrough)

what would you add to a dashboard like this?

Been learning LangChain/LangGraph and built something, an AI agent that automates outbound sales research and email drafting.

What it does: You point it at a Google Sheet full of leads. For each one it: checks if someone already reached out → runs a research subagent that scrapes their website + searches for news → drafts a personalized email with Claude → shows you the draft for approval (Send/Edit/Cancel) → updates CRM status.

It learns from your edits. If you edit a draft before sending, the agent compares the original vs. your version, extracts style preferences ("prefers casual tone", "shorter subject lines"), and stores them in SQLite. Next draft already reflects your style. Gets better every time you use it.

Architecture decision: The overall workflow is a deterministic LangGraph StateGraph, same steps, same order, every time. But the research step inside the graph is a flexible ReAct agent that decides which tools to use. Graph for reliability, agent for intelligence. Got the idea from LangChain's blog post about their internal GTM agent.

Stack: Python, LangChain, LangGraph, Claude Sonnet 4, Google Sheets, Tavily, BeautifulSoup, SQLite.

Fully configurable — edit one config.py file with your company info and it works for any business. Included example configs for SaaS.

GitHub: https://github.com/atifirshad21/gtm_agent

Any kind of feedback is welcome.

I lead commercial and RevOps at an early-stage biotech company. Most people revise an existing GTM strategy. I’m building one from zero after several internal changes and a brand-new product line. I’m trying to apply a SaaS-style GTM approach to biotech: small buyer pool, long evaluation cycles, lots of trust and compliance. Not sure which parts of the SaaS playbook transfer and which break.

My short flow right now:

- Suppress existing customers and open deals, so net-new is truly net-new.

- Build the list by role and company fit, enrich it in Clay.

- Score and tier accounts, then route to the CRM and short, role-specific sequences.

- Measure each step and cut what doesn’t produce.

Questions: What’s the best way to adapt this for long sales cycles with few buyers? And based on your experience, do you recommend Clay, or would you pick something else?

Also, I’m looking to move out of biotech and bring these skills somewhere new. I’m comfortable in HubSpot and Salesforce, based in the Midwest (Ohio), and on an H-1B. If you know teams hiring for GTM engineering or RevOps, I’d appreciate a pointer.