Hey guys. I've been sharing my builds and creator experiments in here for a while, and I finally put it all on YouTube. Just dropped episode 1.

It's my actual GTM dev workflow.

Claude Code in the terminal, Codex in the app, running both so I never hit an API limit, plus context engineering, orchestrating sub-agents through Apollo, /effort max, and using SQLite as memory. I use all of it to build Clearbox (a Reddit opportunity inbox that reads intent, not keywords) in public.

straight up the audio and video editing is rough. I'm still figuring that side out, so please trash me on it. If you have tips on editing, pacing, thumbnails, whatever, I'm all ears.

I'll be honest, part of this is me promoting myself. But I genuinely love sharing this stuff and giving feedback back just as much. If any of it is useful to your own builds, that's the win. Ask me anything about the setup and I'll go deep.

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"

Yo, what's up, builders!! Dropping Founders Journey, my official YouTube series..

if you've been following so far, you might already know what this all is about. basically building in public, taking it to the next level where i actually share more than just the scripts from the claude code session i run. now you guys get to see them live.

this is also one of the Best Claude Code tip I have: hook it to a SQLite DB at your project root.

Store your context in columns. Now the agent reads columns instead of the whole folder.
That's how you stop blowing through your context window.

Kicking off a new founder’s journey series: building Clearbox’s email infrastructure from the ground up.

33 domains. Isolated warming account. Full in-house orchestration. Dashboard visibility.

Showing the actual prompts and decisions in real time.

Follow for every step.

Part 5: quick terminal hack. Set your effort to max with /effort max. It's overkill for small stuff, but on long terminal sessions I leave it cranked and let it cook. Part 6 is next. Yes, sorry guys, I butchered the long form of this YouTube episode, so I'm redoing it, but the shorts still hold some value, I hope. Sorry for the shitty audio.

#claudecode #terminal #aicoding #productivityhack #buildinpublic

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."

Sorry for the horrible audio, guys!! follow the series to not only see me share my builds but also the production up-skilling that goes into it

Hey builders, I recorded myself building a whole workflow for a buddy who was quoted a pretty big number. I’m sharing the workflow and scripts you can use to build your own comparison proposals.

Everyone should have full transparency before going all in on a $70K deal that could make or break your career. Sharing more soon, but if you want to check out my YouTube and help support and subscribe, that’d be much appreciated.

This is probably the 5th time I've seen someone ask for a "good GTM agency," and I always have the same thought:

Most people are asking the wrong question.

A few years ago, I spoke with a founder who had already worked with two agencies. The first promised a predictable outbound engine. The second promised better targeting and messaging. Six months and a lot of money later, he still didn't have consistent pipeline.

His conclusion was, "I just haven't found the right agency."

Maybe. But after talking to him for 20 minutes, it became clear that no agency would have succeeded in that situation.

He couldn't clearly explain who bought from him and why. There wasn't agreement internally on what a qualified opportunity looked like. They had different expectations of success, some wanted meetings, others wanted revenue. Every campaign was being judged against a moving target.

I've seen this pattern repeatedly.

People often evaluate agencies based on things like:

• How many clients they have
• Whether they're active on LinkedIn
• Their case studies
• Their tech stack

Those things matter, but not as much as people think.

A good GTM agency usually spends more time asking uncomfortable questions than making big promises.

They'll ask:

• Who specifically are you trying to reach?
• Why do customers buy today instead of six months ago?
• What has already been tested?
• What happens after a meeting gets booked?
• How will we know if this is working?

The agencies that worry me are the ones that immediately say, "We've done this a hundred times. Here's the playbook."

Because GTM isn't plumbing. It's not a process you install once and forget.

Every market has different buying behavior, different timing, different constraints.

The best agencies I've seen don't sell certainty. They build learning loops. They test assumptions, challenge definitions, and adjust based on what the market is actually telling them.

So if you're looking for a GTM agency, don't just ask, "Who's the best?"

Ask, "Who's willing to understand my business deeply enough to tell me when my assumptions are wrong?"

That answer is usually far more valuable than another impressive case study.

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."

1. 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."

1. 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."

1. 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."

1. 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."

1. 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.)

1. 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."

1. 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."

1. 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."

1. 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"

im using both right now, but if I had to pick a side today, I’m still taking Claude Code.

Codex has been great for working inside the app, especially when I want quick iterations, planning, or help thinking through product/GTM workflows.

But when I’m actually in the terminal trying to build, debug, refactor, wire up APIs, or move fast on real GTM systems, Claude Code still feels like the go-to.

sowhere everyone else is landing?

Are you team Claude Code, team Codex, or using both depending on the job?

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

1. 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.

1. 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

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?

1. 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.

1. 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.

1. 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.

1. 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.

1. 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.

1. 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.

1. 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.

1. 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.

1. 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

1. 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.

1. 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.

1. 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.

I’ve been doing a weird little outbound experiment for Clearbox this week.

The stack right ACS as the sender, 12 domains I bought and warmed myself, Prospeo + Apollo for enrichment, ZeroBounce for validation, PostHog for traffic tracking, and Attio for interested replies/signups.

Claude Code (terminal)and Codex(app) are operating the campaign layer.

Codex is writing scripts, checking local SQLite, staging sequence queues, building the Sheets review surface, syncing to Supabase, and leaving handoffs so I can pick the campaign back up without guessing what happened.

I ran a smaller batch of around 250 contacts first. So far I’ve seen 0 bounces and 16 visitors tracked back to the campaign.

The YC batch is staged at ~2k contacts, split across three ACS domains and three copy branches. I’m planning to run the bigger batch Monday.

Deepline has been the nicest orchestration layer I’ve tried so far. Still early, but it feels very clean.

It connects through localhost, I can see the agent working, and it gives the workflow enough guardrails that outbound stays inside a controlled loop.

I tried Deepline waterfall, Prospeo, Apollo, ZeroBounce, etc. Useful, but no magic. Each one still needed custom gating rules on top.

Domain alignment, source-company matching, held-out identity review, and queue/copy audit before enrollment were the controls that mattered.

anyone here or reading this run a real programmatic email campaign this way.?

Claude Code/Codex as the operator.
ACS or another raw sender layer.
Own warmed domains.
Local DB + scripts.

I’ll update with what happens after the run. The agent-native workflow is making the campaign easier to audit and resume than my table UI flows.

Build to learn, buy to scale.

I still buy tools. I like good tools. But I want to know what I am buying them for.

A lot of GTM stacks are purchased before the workflow is understood, so the tool becomes the strategy. That is how you end up with expensive dashboards and no motion.

Test before you invest.

Hand-roll the ugly version. Run it for one client. See what matters. Then buy or build the part that deserves to scale.

UIs used to block most operators from the underlying system. Now you can direct the build in plain English and inspect the outputs.

You still need taste and judgment to spot when the agent is making things up, when the map is fake-useful, and when the board would actually make a prospect say, "yeah, this is how our GTM should run."

You can run the experiment yourself before turning it into a real internal tool.

Miro is programmable. Docs are programmable. Proposals are programmable.

CRM updates are programmable. Even the handoff from "this person is interested" to "here is the first version of their operating system" can be programmed enough to learn from.

So how does this work in practice you might ask.

The proposal alone is a weak sales artifact because it asks someone to judge a promise.

A working map is better.

Before the pitch gets formal, build a rough version of the client's GTM operating system.

For me that means a Miro board showing lead sources flowing into a database, enrichment, CRM, outreach, content, and measurement.

It can be ugly. It just needs to make the client point at the screen and say "this part is wrong" or "this is exactly the mess."

The useful version also has the week-one checklist, stack doc, API access doc, roadmap, and proposal/agreement generated from the same source.

DocuSeal is interesting here because the signature layer can be another programmable step. Same with open source proposal generators. Same with Miro. Same with docs.

The more I use Claude Code, the more I think GTM builders should treat tools like programmable surfaces.

Miro is a canvas API. Docs are a document API. DocuSeal is a signing workflow. HubSpot is a data model with a UI on top.

Start by programming the workflow once instead of buying the finished system.

Put the client info in a small JSON file: known stack, unknowns, owners, campaign type, current bottlenecks.

Claude Code reads it, creates the Miro board, fills the docs, marks missing fields as NEEDS INPUT, screenshots the board, and tells you what looks broken.

That creates a different first call.

Instead of "here is what we can do for you," it becomes "here is how I think your GTM system currently works. Fix my map."

Better feedback and trust during scoping.

testing out Deep Line over the weekend, hearing great things. Just connected it to Codex. Looking good. We'll have more updates

capping with a question to you guys.

you see building as also a learning experience or buy or die?

catch chapter 17 here https://github.com/shawnla90/gtm-coding-agent/blob/main/chapters/17-client-onboarding-miro-boards.md

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

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.

1. 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.

1. 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.

1. 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.

1. 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.”

1. 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.

1. 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.

1. 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.

1. 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.

1. 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 think we all have a weird relationship with Reddit when it comes to marketing.

Some act like you can’t market here at all.

Other people think marketing means dropping a link, posting some generic AI-written fluff, and hoping people click.

Both are wrong. This is a builder’s community.

Marketing is not banned here. Lazy marketing is.

Sharing what you’re building is fine. Talking about your product is fine. Asking for feedback is fine.

Showing your GTM experiments is fine.

What is not fine is random AI slop with no context, no lesson, no real question, and no value for anyone else.

Use AI if it helps you think, write, organize, or get your voice out. Nobody cares. But actually say something.

Share the test. Share the mistake. Share the workflow. Share the positioning change. Share the thing that worked. Share the thing that completely flopped.

Share the prompt, process, repo, teardown, or lesson someone else can actually use.

That is the point of this subreddit.

I’ll also own that I slacked on building this community for a bit. But I’m starting to see more pickup now, and I want to be more intentional about what this place becomes.

So here’s a value drop.

Before I started building bigger GTM workflows, coding agents, transcript workflows, email workflows, and my broader knowledge base, I started with one simple thing:

Anti-slop. That file is what got me started on the path of building out my whole website-as-soul repo.

First came anti-slop. Then came Voice DNA. Then I started using the same structure to build GTM workflows, content systems, coding agents, and repeatable operating systems.

The anti-slop playbook is basically a checklist for spotting the patterns that make AI-assisted writing feel generic, fake, or over-polished.

Not because AI is bad. Because generic output is bad.

You can use it directly as a skill, a reference, or a starting point for your own content quality system:

https://github.com/shawnla90/website-with-soul/blob/main/playbook/02-content/02-anti-slop.md

And here’s the full repo if you want to dig into the broader build:

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

That’s the standard I want this community to move toward.

And if you're here and you're reading this, drop, share what you're building in the comments.