analytics-tracking

Overview

What the analytics-tracking skill does

The analytics-tracking skill helps you design, implement, and audit analytics tracking so you can trust your data and make better marketing and product decisions. It focuses on:

• Translating business questions into measurable events
• Designing clean event naming and parameter conventions
• Implementing tracking in Google Analytics 4 (GA4) and Google Tag Manager (GTM)
• Structuring UTM parameters and campaigns for clear attribution
• Building tracking plans that feed reporting and performance analysis

Instead of collecting random clicks and page views, analytics-tracking keeps you focused on events that answer, “Is this working?” for your website, product, and campaigns.

Who this skill is for

Use analytics-tracking when you are:

• A marketing manager who needs reliable conversion tracking for campaigns
• A product manager who wants to understand feature usage and activation
• A founder or growth lead trying to measure if experiments are working
• A developer responsible for event implementation in the front end or via tag managers
• An analyst who needs clean, consistent event data for dashboards and reports

It’s especially useful if you work heavily in the Google stack: GA4, GTM, Google Ads, Google Sheets, or Google Docs tracking plans.

Problems the analytics-tracking skill solves

This skill is designed for situations where you or your team say things like:

• “We set up GA4 but don’t trust the numbers.”
• “Our events are messy and inconsistent.”
• “We don’t know what to track for this new feature or funnel.”
• “UTMs are all over the place; we can’t see which channels actually work.”
• “GTM is firing, but we’re not sure events are configured correctly.”

Using the repository references, the skill helps you:

• Run an initial assessment of your current tracking setup
• Apply the principle “track for decisions, not data”
• Create or refine a tracking plan with clear event names, triggers, and parameters
• Implement events in GA4 using gtag.js or GTM
• Use a robust event library tailored to your business model (marketing site, SaaS, ecommerce, etc.)

When analytics-tracking is and isn’t a good fit

Use analytics-tracking when:

• You need to set up or improve GA4 + GTM tracking
• You’re designing or auditing event tracking, conversions, or attribution
• You’re defining UTM strategies or standardizing campaign naming
• You’re mapping out product analytics events (e.g., signups, feature usage, upgrades)

It’s not the primary tool when:

• You only need help with A/B test design and measurement (use the separate ab-test-setup skill for that)
• You’re doing advanced warehouse modeling or BI-only questions (the skill focuses on instrumentation and implementation, not SQL modeling)

If the core question is, “How do we measure this?” or “How do we know if this is working?”, analytics-tracking is the right choice.

Key reference files in the repository

The analytics-tracking skill is backed by several focused references:

• SKILL.md – The core behavior definition, including initial assessment steps and core principles
• references/event-library.md – A structured event library by context (marketing site, product, monetization, ecommerce, B2B/SaaS)
• references/ga4-implementation.md – Detailed GA4 setup and implementation guidance
• references/gtm-implementation.md – Detailed Google Tag Manager structure and implementation guide
• evals/evals.json – Example scenarios and expected best-practice responses (e.g., SaaS tracking plans, UTM conventions)

These files let the skill move from generic advice to specific, implementation-ready guidance.

How to Use

Installation and setup

1. Install the analytics-tracking skill

Use the Skills CLI to add the skill from the coreyhaines31/marketingskills repository:

npx skills add https://github.com/coreyhaines31/marketingskills --skill analytics-tracking

This pulls in the analytics-tracking configuration, evaluation prompts, and references so your agent can provide detailed, implementation-focused answers.

2. Review the included references

After installation, open these files in your environment for context:

• SKILL.md – Understand the scope, assumptions, and core principles
• references/event-library.md – Browse recommended events and parameters
• references/ga4-implementation.md – See how to configure GA4, custom events, conversions, and debugging
• references/gtm-implementation.md – Learn container structure, triggers, variables, and data layer usage
• evals/evals.json – See example prompts and expected output formats (e.g., tracking plans)

Use these as templates and guardrails, not as copy‑paste checklists. Adapt them to your product, compliance requirements, and tech stack.

Typical workflows this skill supports

1. Designing a tracking plan from scratch

When you ask the agent something like:

“Help me set up analytics tracking for our B2B SaaS product in GA4 and GTM. We need to track signups, feature usage, and upgrade events.”

The analytics-tracking skill will:

1. Check for product marketing context

   • If .agents/product-marketing-context.md (or older .claude/product-marketing-context.md) exists, it will read that first to avoid repeating questions.

2. Apply the “track for decisions, not data” principle

   • Clarify which decisions you want to inform (e.g., “Which features drive upgrades?” or “Which channels drive trial signups?”).

3. Define core events and naming conventions

   • Use the object_action event naming convention (e.g., signup_completed, feature_used, plan_upgraded).
   • Pull from references/event-library.md for SaaS-specific events like:
     • signup_completed
     • trial_started
     • feature_used
     • plan_upgraded
     • subscription_canceled

4. Produce a structured tracking plan

   • Output in a table-like format (suitable for Google Sheets or Docs) with:
     • Event name
     • Trigger (what user action fires it)
     • Parameters (e.g., plan_name, feature_name, pricing_page_variant)
     • Purpose/decision the event supports

5. Provide GA4 implementation details

   • Suggest GA4 event configuration, including recommended parameters and when to mark events as conversions.

6. Provide GTM data layer patterns

   • Show example dataLayer.push snippets for your front end, which you can hand to developers, and how to connect those to GA4 Event tags in GTM.

This workflow is ideal when launching a new product, redesigning your funnel, or cleaning up legacy tracking.

2. Auditing existing GA4 and GTM implementations

If you ask something like:

“Our GA4 data doesn’t look right. Can you help us audit our tracking?”

The skill will guide you to:

• Review current data streams and enhanced measurement (references/ga4-implementation.md)
• Check conversion settings, custom dimensions, and audiences for misconfigurations
• Inspect GTM container structure, tag naming, triggers, and variables (references/gtm-implementation.md)
• Validate events in DebugView and GTM Preview mode
• Compare your current event list to the event library to spot gaps or duplicates

You can then prioritize fixes, such as consolidating events, renaming parameters, or standardizing triggers.

3. Setting up UTM parameters and attribution structure

When you ask something like:

“What UTM parameters should we use for Google Ads, Meta, LinkedIn, and our newsletter?”

Based on evaluation guidance in evals/evals.json, analytics-tracking will:

• Recommend a consistent UTM strategy (e.g., utm_source, utm_medium, utm_campaign, utm_term, utm_content)
• Suggest channel-appropriate values, such as:
  • utm_source: google, meta, linkedin, newsletter
  • utm_medium: cpc, paid_social, email, social
• Help standardize campaign naming across platforms for clean GA4 reporting
• Show how to check that UTMs are being captured correctly in GA4

You can then document these conventions in a Google Sheet or internal playbook for your team.

4. Documenting tracking for handoff to developers

If you need to turn strategy into implementation instructions, analytics-tracking can:

• Take your tracking plan and generate:
  • GTM data layer specs (e.g., dataLayer.push({ event: 'feature_used', feature_name: 'bulk_import' }))
  • Notes on where to add these calls in your frontend code
  • Guidance on creating matching GA4 Event tags and triggers in GTM

This is helpful for frontend developers who need exact event names, parameters, and firing conditions.

Best practices for getting good results

• Provide context first: Share your product type (SaaS, ecommerce, marketplace), main goals, and current tools (GA4-only, GA4 + GTM, Segment, etc.).
• Clarify decisions: Specify what you want to learn (e.g., “Which channel drives signups?” or “Does feature X increase retention?”).
• Mention constraints: If you have privacy or compliance requirements, note them so the tracking plan stays realistic.
• Iterate: Start with a small core event set, then ask the skill to refine or extend it as you implement and learn.

FAQ

When should I use the analytics-tracking skill instead of ab-test-setup?

Use analytics-tracking when you are:

• Designing or fixing your core tracking foundation (events, conversions, UTMs, GA4/GTM setup)
• Trying to answer, “How do we measure this feature, page, or campaign?”

Use ab-test-setup when your main concern is:

• Structuring A/B tests, test variants, and experiment metrics
• Ensuring your experiments are measured cleanly and statistically

In practice, you often use analytics-tracking to put the baseline tracking in place, then layer A/B test measurement on top.

Which tools does analytics-tracking focus on?

Based on the repository references, analytics-tracking is optimized for the Google analytics stack:

• Google Analytics 4 (GA4) – configuration, custom events, conversions, audiences, debugging
• Google Tag Manager (GTM) – container structure, triggers, variables, data layer patterns
• Google Ads integration – via GA4 linking and conversion imports (as covered in GA4 implementation guidance)

It also supports broader analytics contexts like Mixpanel or Segment conceptually (events, properties, tracking plans), but the most concrete implementation details are for GA4 + GTM.

Can this skill help with front-end implementation details?

Yes, to a practical extent. The skill can:

• Suggest event names and parameters suitable for front-end tracking
• Provide example dataLayer.push patterns for GTM
• Explain where events typically fire (e.g., button clicks, form submissions, page loads)

For very framework-specific code (e.g., React hooks, Vue components), you may still need developer input, but analytics-tracking gives a clear blueprint for what needs to be implemented and how it should behave.

How detailed are the GA4 and GTM guides?

The GA4 and GTM references are fairly detailed and cover:

• For GA4 (references/ga4-implementation.md):

  • Data streams and enhanced measurement
  • Recommended events (including ecommerce)
  • Conversions, event parameters, custom dimensions/metrics
  • Audience creation and debugging tools
  • Data quality considerations and Google Ads integration

• For GTM (references/gtm-implementation.md):

  • Tags, triggers, and variables
  • Container naming conventions
  • Data layer patterns
  • Common GA4 and pixel tag setups
  • Preview/debugging, workspaces, and versioning

The skill uses these to provide implementation-ready guidance, not just high-level advice.

Will analytics-tracking tell me exactly which events to track for my business?

It will give you strong, opinionated starting points using the event library and best practices, especially for marketing sites, SaaS products, and ecommerce. However, it will still ask clarifying questions about your:

• Business model and pricing
• Core conversion actions
• Main acquisition channels
• Key user journeys and features

This ensures the tracking plan maps to your real decisions instead of being a generic event list.

How can I use this skill with Google Sheets or Docs?

Many teams document their tracking plans in Google Sheets or Google Docs. With analytics-tracking, you can:

• Ask for a tracking plan formatted as a table so you can paste it directly into a sheet
• Generate parameter dictionaries and naming conventions suitable for internal documentation
• Iterate on that plan with the agent as you refine your analytics implementation

This creates a shared, living source of truth between marketers, product managers, analysts, and developers.

What if my analytics “isn’t working” or events aren’t firing?

You can describe the symptoms (e.g., events missing in GA4, conversion counts off, GTM preview not showing tags), and analytics-tracking will walk you through:

• Checking GTM Preview for tag firing
• Verifying dataLayer events and parameters
• Using GA4 DebugView and real-time reports
• Confirming that conversions are properly defined and receiving data

It will then suggest concrete debugging steps and configuration checks based on the GA4 and GTM reference guides.