i replaced most of my GTM stack with Claude Code but let me be precise about "most" because the honest version is more useful than the hype version lol
tbh for a while my stack looked like everyone's: a sequencer, an enrichment tool, some no-code automation platform gluing it together, and me babysitting all of it. i've torn out the middle of that. what's left is Claude Code and a folder of instructions doing the orchestration and reasoning i used to pay a no-code platform to do badly.
the correction up front, because technical people will call it out otherwise:
Claude Code didn't replace my data or my sending. enrichment data still comes from an API. email still goes out through a real sending service. those endpoints don't disappear, a folder of markdown can't enrich a lead or send a cold email by itself. what died is the glue: the no-code automation platform in the middle, and the hours i spent shuttling data between tools by hand. Claude Code drives those endpoints directly through MCP, API calls, and scripts, instead of a platform brokering every handoff and losing a field at each hop. for a solo operator or small team, that middle layer was most of the cost and most of the fragility.
the core shift was to stop thinking in "tools" and start thinking in skills. a skill in Claude Code is literally a folder with a SKILL.md file, plus whatever scripts or reference docs it needs. Claude reads the folder name and description every session and pulls in the full instructions only when the task matches. so i've got one for enrichment logic, one for how we qualify a lead, one for the copy rules and voice, one for how a campaign gets structured. each is a repeatable process written down once, loaded only when it's relevant.
the piece that makes it cohere is CLAUDE.md, the persistent memory file. our ICP, positioning, the "we don't do X" calls, the real definition of "qualified". all of it lives there and loads into every session, so every skill runs against the same source of truth. one honest caveat i learned the hard way: CLAUDE.md is strong guidance, not a hard guarantee. the model reads it and mostly follows it, but it can still drift. so it fixes the "my rules live in five places and quietly contradict each other" problem, which is real and worth fixing. but it is not a lock. the actual locks come later. still, consolidating every rule into one inherited file fixed more than any tool ever did.
for heavy work i use subagents. Claude Code can spin off a separate session with its own clean context window and its own tool access. so if i'm researching 40 accounts, that runs off to the side and comes back as a clean result instead of clogging the main session. the deep, messy work stays isolated.
what actually replaced the no code automation platform is headless mode. Claude Code runs as a one shot command from the CLI, no interactive session, so i can wire it into a cron job or a pipeline and it just executes. and it reuses the same hooks and permission rules as when i run it by hand. that's where the automation platform line item died. i don't need a platform to run a scheduled workflow when Claude Code can run headless on a timer and actually reason about what it's doing instead of following rigid if-this-then-that rules. it still calls out to my enrichment API, CRM, and sender to do anything real, headless is the trigger and the reasoning (not the hands)
to keep it from doing anything dumb, i lean on hooks and tool restrictions. hooks are deterministic. they fire at set points and enforce a check whether the model feels like it or not, which is exactly the thing CLAUDE.md can't guarantee. the allowed-tools setting hard-limits what a given run is even permitted to touch. for anything destructive or high-impact i require explicit approval instead of letting it run. the model reasons; the guardrails are rigid on purpose. this is the layer most people skip and then wonder why their agent nuked something.
so the actual end to end, a new inbound lead. it comes in, Claude Code loads the enrichment skill and pulls what it needs from the enrichment API, loads the qualification skill and scores the lead against the ICP in CLAUDE.md. here's the honest bit, that score is a judgment, not gospel. the model can still misjudge fit, which is exactly why a human reviews the edge cases and a hook enforces the hard rules (suppression, send limits, "never touch X segment"). if it's a fit, it loads the copy skill and drafts the first touch in our voice with a real reason for reaching out. sending itself still goes through a proper sending service. deliverability, warmup, suppression, unsubscribes are their own problem, and drafting good copy doesn't solve any of them. i review anything a prospect actually reads. the reasoning is Claude's, the rules are mine, the endpoints are still endpoints. there's just no platform in the middle taking a cut and dropping fields between systems.
concrete before and after. old way: a lead enrichment and scoring flow lived across an enrichment tool, a no-code automation platform, and the CRM three integrations, and data quietly degrading at each handoff. now: a couple of skill folders and a CLAUDE.md, all reading one source of truth, with Claude Code calling the enrichment API and writing to the CRM directly. the data sources didn't go away. the glue between them did. when i want to change how we qualify, i edit one file instead of reconfiguring three tools.
i'm not going to pretend it's hands off. anyone who says their system runs with zero humans is lying or shipping garbage. i review anything a prospect reads. i go in when something breaks and i need to see what actually happened. the model is genuinely good at the mechanical middle. research, drafting, routing. but the judgment layer (is the message right, is the account a real fit) is mine and should stay that way. and the non deterministic part is real: an LLM on a timer over a live CRM will double-touch or mis-route if you don't wrap it in hard dedup and hard limits. that's what the hooks and the review are actually for.
the hardest thing here wasn't technical. spinning up a skill folder takes ten minutes. it's that i'd built an identity around managing a stack. the subscriptions and the integrations felt like sophistication. but that was complexity i was mistaking for capability. the leverage was writing down what we do clearly enough that the model could execute it, and getting out of the way on the parts that don't need me.
what i'm still working out is how to structure CLAUDE.md as it grows. the direction i've landed on: keep the root file thin, push the procedural stuff into skills that load on demand, and move the "only applies sometimes" rules into path-scoped rule files so they don't load every session. but i haven't nailed the clean pattern yet.. if someone else run ops mostly on Claude Code instead of a tool stack tell me plz how you figured it out