The Follow-Through Problem
Seven years in marketing. The strategy almost never kills the campaign.
The follow-through does.
You build the right plan. Nail the positioning. Two weeks in, nobody checked the numbers. The reporting got pushed. The strategy that should've updated based on what the data said didn't get touched — everyone was onto the next client, the next fire. The work at the beginning was good. The system around it wasn't.
I used to think this was a people problem. Hire better, build better processes, set more reminders. There's truth in that. But the more AI I've introduced into my workflow, the more I wonder if I had the frame wrong.
Maybe follow-through is a design problem. We've just never had the tools to design it properly.
A few weeks ago I started using a tool called Sidecar. Terminal interface for working with AI coding agents — Claude, Cursor, whatever. It sits next to your agent and shows you everything: what files changed, what it's planning, the full conversation history across every session.
I'm not a developer. I've been building tools and prototypes for about a year, learning as I go. Still a tourist in a lot of this.
Something about Sidecar clicked in a way I wasn't expecting.
Not the code part. The coordination part. Multiple agents on the same project, and instead of things falling through cracks or diverging into chaos, there was a layer tracking everything — enforcing handoffs, keeping a clean record of what happened and why. The agents weren't just generating output. They were operating inside a structure that made their work coherent over time.
I kept thinking: this is what I've been trying to build for seven years.
In the wrong direction.
What if a marketing operation ran the way a well-engineered software system does? Not as a metaphor. As architecture.
One agent builds strategy. Documents the reasoning, versions every decision. When something changes — a competitive signal, a shift in the data — it updates the plan and logs why. Another handles execution. Reads the strategy, produces the work, runs campaigns. Not operating on vibes or last week's Slack message — working from a clean, current source of truth. A third handles reporting. Pulls the data, surfaces what's working and what isn't, and instead of putting that in a folder nobody opens, feeds it directly back to the strategy agent. Which updates the plan. Which the execution agent reads next cycle.
The loop closes itself. Nobody has to remember.
That's the part that keeps getting me. The remembering.
Someone meant to follow up on that A/B test. Someone was going to update the brief after last month's results. Someone was supposed to flag that the messaging was drifting. But there was a client emergency, or a new pitch, or just the ordinary entropy of a week with too much in it.
An agent team wired this way doesn't forget. Not because AI is smarter — it frequently isn't — but because forgetting isn't in its nature. The hook fires. The report runs. The strategy gets the new information. Every time.
Over enough cycles, something starts to look like institutional knowledge. What messaging worked with this kind of client. What timing performs best. What the gap usually is between what was planned and what actually happened. Accumulated, logged, available for the next iteration.
You're not automating tasks. You're training a team.
The infrastructure underneath this is something developers have been using for fifty years. Git — version control that tracks every change, builds in review before anything goes live, creates hooks that trigger automatic handoffs.
It hasn't hit marketing. Not at the infrastructure level.
The primitives translate almost exactly. A branch is a test strategy running in parallel without touching what's live. A commit is a locked decision with a message — why we made this call, when, based on what. A hook fires when reporting finishes and strategy needs to know. The history is training data. Every decision, every outcome, forever.
I'm not saying put git in your marketing team. Most people should never see a terminal. But the coordination problem git solved for developers is the same one showing up now with agents doing business work. Nobody's built the layer that solves it in a language that doesn't require knowing what a repository is.
I don't have a product to show you. Not sure what shape this takes yet — infrastructure, a product layer, something I haven't figured out how to name.
What I have is a pattern I can't stop seeing. In Sidecar, in my own agency, in watching how AI tools get adopted and then slowly drift into chaos because nothing holds the work together between sessions.
I might be early. Might be confused. Probably some of both.
I'd rather write this now — messy, before I've worked it all out — than wait until it's polished enough to present.
Let's find out.
First in a series. Building in public — seven years watching this problem from every seat in the room.