The agentic shift in martech: Three examples

Legacy companies are quietly using Claude and Codex to collapse workflows that used to take weeks, from infrastructure setup to generating tracking code and acting on analytics.

Scott Brinker recently wrote about how companies are replacing legacy martech stacks with agents built on composable infrastructure. It's a sharp framing, and it maps closely to what we are hearing from customers.

We talk to a lot of teams. And what's been genuinely surprising isn't what the Bay Area AI-native startups are doing. It's the companies in deeply legacy spaces (traditional financial services, established SaaS) who are quietly deploying agents and compressing workflows that used to take weeks into hours.

Here are three example use cases:

1. Infrastructure setup as a conversation

This one might seem obvious, but the magnitude of the shift is easy to miss.

Infrastructure as code was already the right pattern before AI: version control, auditability, rollback, reproducibility. Tools like RudderStack were increasingly config-driven for exactly these reasons. But IaC had a steep learning curve. You had to internalize obscure YAML structures, understand Terraform's declarative model, or accept the limitations of clicking through a vendor UI and losing auditability in the process.

That tradeoff is gone. Engineers are now describing infrastructure in plain language, pointed at vendor documentation, and getting production-grade config files out the other side. The output is auditable, version-controlled, and rollback-friendly. The experience is easier than clicking on a UI.

The impact is more than just speed. It's also access — junior engineers and technical PMs who previously couldn't touch infrastructure are now authoring it confidently. As Brinker put it, “As that infrastructure becomes more accessible and easier to leverage, more teams will build more things on top of it — making that infrastructure more valuable.”

2. Tracking instrumentation without waiting on engineering

This is the one that consistently gets the strongest reaction from customers, because the pain it removes is so visceral.

Every company with a custom tracking plan knows the drill. Marketing wants a new event for a segment, a product needs a custom property for an experiment. The request goes into the engineering backlog and days or sometimes weeks pass. Tracking is nobody's top priority. It's invisible infrastructure that only becomes visible when it's broken or missing.

With Claude Code or Codex, multiple customers have collapsed that cycle dramatically. In several cases, PMs — and in some instances, technical marketers — are now generating pull requests for tracking instrumentation themselves. They describe the event, Claude generates the code against the existing tracking plan, and the PR goes through a standard review process.

The key integration that makes this work reliably: setting up the RudderStack MCP so the agent confirms against the tracking plan before generating code. That validation step is what keeps the output trustworthy rather than just fast.

This is a meaningful organizational shift. It moves a bottleneck out of the engineering queue without sacrificing code quality or consistency.

3. Analytics that closes the loop automatically

This is the most consequential one, and the direction it's heading is significant.

The traditional analytics workflow is well-worn: analysts build dashboards, PMs review them, growth teams generate hypotheses, engineers implement changes, and the cycle repeats over days or weeks. Each handoff bleeds time. The OODA loop (Observe, Orient, Decide, Act) grinds at human pace.

One customer pointed Claude at their product drop-off funnels and their application code. The recommendations it surfaced were more actionable than what their junior PMs were producing.

That's not a knock on PMs. It's a reflection of what happens when an agent can simultaneously hold the event data, the funnel shape, and the application implementation in context. It can reason across all three in a way that's difficult for humans who context-switch between tools.

The next step that the team is exploring: automatically generating pull requests from those recommendations. Instead of the agent surfacing an insight for a human to act on, the agent surfaces the insight and the proposed code change together. Projects like Shopify's pi-autoresearch are pointing in this direction, with automated research pipelines that close the loop between observation and implementation.

The implication for analytics platforms is significant. The value isn't in the dashboard anymore. It's whether the system can generate and execute a recommendation without waiting for a human to schedule three meetings first.

What's striking across all three of these isn't the technology. It's where the friction used to live. Infrastructure configuration, tracking instrumentation, analytics-to-implementation handoffs. These weren't glamorous problems. They were just slow, expensive, and bottlenecked on engineering attention. Agents are carving through exactly those bottlenecks.

More to come. In the next post, I'll cover a few more use cases we're seeing from customers — including some that are harder to anticipate.