Sales problems,
software solutions.

I didn't come to this through computer science. I ran a recording studio. Then I did manual labor. Then I was an SDR making cold calls, and I kept noticing the same thing everywhere I looked: revenue teams run on tribal knowledge and duct tape. The list got built the way it got built because that's how Sarah built it before she left. The CRM field means something nobody remembers. The sequence is still sending because nobody turned it off.

GTM is tribal. It doesn't have to be.

Somewhere in there I started using AI tools. Thousands of hours across a few years, before it was a job title. Pattern recognition has always been my thing: I see systems, not tasks. So when the models got good enough to write real code, something clicked: I didn't need to become an engineer. I needed to point the engineering at the problems I'd been living inside for years.

That's my whole definition of GTM engineering, and I think it's better understood as a set of principles than a defined role. The core principle: apply software solutions to sales problems. Not "go buy a tool." Ask where code, workflows, AI, and automation create real leverage in the revenue function, then build exactly that.

The jobs-to-be-done knowledge is what matters. Not the syntax.

There's a trap in this work I call the dopamine-hit workflow. Building a CRUD app with a sleek frontend by prompting Cursor is genuinely cool. It feels productive. But does it close deals? Does it drive pipeline? Almost certainly not. I've lived the bottlenecks at every stage of the funnel, so I build for the outcome, not the build. Every system in this portfolio exists because a revenue problem was bleeding: replies getting dropped, attribution being argued in Slack threads, job-change signals rotting in a dashboard nobody opened.

And I hold my own work to a harder standard than "it demos well." My systems have preflight checks before anything touches a sequencer. Human gates where taste matters. Reconcile crons because webhooks lie. Rollback files before bulk CRM writes. The boring parts are the parts that make it production instead of a party trick.

I'm not building automations. I'm building an employee.

An automation runs a script and breaks when someone renames a field. An employee interprets a request, checks the context, asks when it isn't sure, and gets more useful every week. That's what my Claude Code environment actually is: an operating system for AI agents. Identity and judgment rules always loaded, domain knowledge that loads when the task calls for it, API docs that heal themselves when a call fails, and a memory that compounds every gotcha so no lesson gets paid for twice.

This is also where I think the whole industry is going. The future of SaaS is headless: you log in once to get the API key, and you never touch the UI again. Agents, context, APIs. Complete API parity, machine-readable docs, bulk operations. Vendors who competed on pretty dashboards just lost their competitive advantage, because if I never open the UI, I don't care how smooth the onboarding flow is.

My entire body of work is collapsing the GTM stack into a single chat window.

The value was never in clicking the buttons. It was in understanding which buttons to click, and that understanding is getting commoditized fast. What doesn't get commoditized is the judgment: knowing which signals matter, which contacts to never email, which numbers leadership can actually trust. So that's what I encode. The gates, the exclusion rules, the human pauses. Judgment as infrastructure.

One more thing I believe about the people side: curiosity beats credentials. When I evaluate anyone for this kind of work, and when anyone evaluates me, the question is the same: what have you built? Not certifications, not tenure. The gap between "here's what I've tried" and "I haven't touched any of this" is not a training gap. It's a curiosity gap, and you can't teach curiosity.

So here's who you're getting: a former studio operator from Charlotte who rides a Honda VFR, owns a Xoloitzcuintli, sees patterns compulsively, and has spent the last few years turning that into production revenue systems, webhooks, pipelines, attribution engines, and a Claude Code operating system that comes with me wherever I go.

Give me the keys and the agency.
I'll bring the factory.