Data-Driven Content Positioning with AI Coding Agents: A Four-Step Framework

The real problem isn’t a shortage of ideas — it’s a shortage of verifiable judgment

“Almost any topic could work, but nothing ever feels right.” Nearly every creator has lived in this loop. The cause is rarely creative exhaustion. It’s that the decision has no data behind it. A human can weigh only a handful of samples at once, while the patterns that actually decide whether content succeeds are buried in the distribution of hundreds or thousands of past samples. Opening a spreadsheet and scanning it row by row, or summarizing a few viral headlines from gut feel, produces fragile conclusions — shift the time window and they fall apart.

So invert the order of operations: turn the judgment process into data first, then let an AI coding agent carry the grunt work — fetching data, cleaning it, computing metrics, building visualizations, and drafting the write-up. Humans keep only the value judgment and the creative angle. The four-step positioning method below is built around exactly that split.

Four steps: from self-audit to an executable conclusion

Step 1 — Why: turn your own content archive into structured data

Your existing archive is the most underrated data source you have. Its value is a clean measurement basis and a short causal chain: same account, same audience, same voice, fewest variables, most reliable conclusions.

Step one isn’t analysis — it’s flattening unstructured content into a table. Suggested fields:

Category	Suggested fields
Identifiers	Content ID, title, publish time, format (article / short video / long video)
Cost	Word count of body, shoot duration, estimated production hours
Results	Impressions or plays, likes, comments, saves, shares, new followers
Topics	Level-1 topic, level-2 topic, keyword tags, headline pattern template

Once you have the detail rows, compute only derived metrics — don’t stop at absolute values. Four that are common and genuinely explanatory:

engagement_rate  = (likes + comments + shares + favorites) / impressions
favorite_rate    = favorites / plays          # long-tail saves: "worth keeping" value over time
share_rate       = shares / plays             # social currency: intensity of opinion or emotion
follower_cvr     = new_followers / plays      # real conversion of traffic into an asset

One judgment call that’s easy to miss: absolute play count is heavily shaped by the distribution algorithm and swings wildly, while save rate and share rate sit much closer to the content itself and stay more stable across cycles. Using those to locate a content “gene” is far more reliable than chasing the play-count peak of one hit.

Step 2 — How: market reconnaissance from public data

Your own data answers “what am I good at.” It doesn’t answer “what is the market rewarding right now.” For that, collect publicly visible data from mainstream content platforms (titles, plays, likes, comments, saves, publish time, channel), using only the fields each platform displays publicly and respecting that site’s terms of use and rate limits.

What matters is not volume but a consistent measurement basis and sound statistics:

• The denominator must be fixed. Decide once per task whether engagement rate is computed on impressions or on plays, and never mix them, or every cross-comparison is void.
• Use percentiles, not averages. Content data is a classic long-tail distribution: a few top performers drag the mean to a point with no reference value. Read the median and the interquartile range.
• Aggregate topics, don’t stack headlines. Tokenize and semantically cluster titles into topic groups, then compare the distribution of save rate and share rate across clusters. That is what shows which kinds of content stay in demand.
• Watch for supply gaps. High demand with little quality supply usually beats high demand with saturated supply.

Step 3 — Action: the intersection matrix of strengths and opportunities

Put both sets of conclusions in one coordinate system: horizontal axis = market-demand percentile, vertical axis = your own historical performance percentile. Upper right is the main battleground, upper left is differentiation, lower right is a low-efficiency lane to avoid.

To make the conclusions rankable, add a transparent priority score and adjust the weights to the account’s stage:

priority = 0.35 * percentile(own historical performance)
         + 0.30 * percentile(market demand)
         + 0.20 * supply gap coefficient
         + 0.15 * (1 / relative production cost)
# all percentiles normalized to [0, 1] so the metrics can be weighted together

The score exists to make the discussion evidence-based, not to replace judgment. When two directions score closely, the creator’s preference for a content form’s long-term shape should decide.

Step 4 — Delivery: write the report for people

Conclusions need a structure that can carry them. Suggested layout, conclusion first and evidence after:

1. Conclusion page: three priority directions, one sentence of reasoning each, plus a first content example.
2. Evidence page: metric comparison charts, topic-cluster distribution, interquartile range charts.
3. Execution page: content schedule for the next four weeks, with cost and expected return range per content type.
4. Risk page: directions with insufficient sample size, measurement-basis limitations, possible seasonal bias.

Evaluating an AI coding agent

Once the approach is settled, execution efficiency depends on the tool. Don’t judge a coding agent on a single generation; evaluate it on long-horizon task completion:

• Tool-call stability: across many rounds of file reads and writes, command execution, and failure retries, does it error rarely and recover on its own? This is the main variable in whether a long task survives.
• Context capacity: with several documents and multiple data tables in play, can it hold the goal without drift and locate key fields accurately?
• Output quality: not just correct numbers, but readable charts, clear heading hierarchy, sensible color and whitespace — this decides whether the team can actually use the report.
• Throughput and latency: analysis jobs that run for tens of minutes make waiting cost a real drag on iteration count.
• Safety boundaries: can operations be constrained to a designated working directory, do high-risk operations require human confirmation, is data sent out without authorization? For many teams this one is non-negotiable.

Handing the task to an agent: six engineering practices

1. Directory and file conventions first

project/
├── data/raw/          # raw exports, read-only, never modified
├── data/clean/        # cleaned intermediate results
├── scripts/           # reproducible scripts
├── reports/figures/   # chart outputs
└── docs/task.md       # task brief

Marking raw read-only is the single most effective way to stop the agent from “helpfully editing the data.”

2. A context task brief template

The first thing you hand the agent isn’t data — it’s a brief. Fill in all six items (role, goal, inputs, metric definitions, output format, prohibitions) and rework drops sharply:

# Task: Content Topic Positioning Analysis
- Goal: output 3 priority content directions with supporting data
- Inputs: data/raw/history.csv (own content detail), data/raw/market.csv (public data)
- Metric definitions:
    engagement_rate = (likes+comments+shares+favorites)/impressions
    all ratio metrics rounded to 4 decimal places; record as null when the denominator is 0
- Statistics: always use median and quartiles for cross-topic comparison, never the mean
- Output: charts under reports/ plus one conclusion-first analysis report
- Prohibited: modifying any file under data/raw; introducing data not present in the inputs

3. Scripts first, no one-off mental math

Require the agent to produce runnable extraction and statistics scripts first, then interpret their output. That is what makes a conclusion reproducible and lets you rerun it in one shot next month when the data refreshes. Any number a script cannot reproduce doesn’t belong in the conclusions.

4. Persist intermediate results; split long tasks into stages

Cut the pipeline into collect → clean → compute metrics → cluster topics → chart → write, and write each stage’s output to data/clean/. If one stage breaks you only rerun that stage, and you also lower the per-run context pressure so early constraints don’t get lost halfway through.

5. Three checks: cross-validate the key numbers

Check 1 conservation: cleaned rows + dropped rows == raw rows
Check 2 sampling: randomly pull 20 rows and manually verify the derived metrics
Check 3 back-calculation: derive absolute values from totals and ratios, compare with raw aggregates

A checking layer turns “the agent said something wrong” from a random accident into an engineering problem you can detect and localize.

6. Humans keep the final call

Agents are good at enumeration and calculation and bad at carrying business judgment. Have one produce candidate directions plus evidence strength, and you make the tradeoff. That is the balance point between speed and risk.

Four high-frequency traps

• Drifting measurement basis: mixing plays and impressions inside one report invalidates every ranking conclusion built on it.
• Correlation read as causation: a high save rate on a topic doesn’t mean it’s why your account gained followers; it may only reflect audience composition.
• The mean trap: drawing conclusions from averages on long-tail data is letting a handful of hits define an entire direction.
• Pretty but not actionable: elegant charts with no cost estimate and no schedule can’t be executed by the team.

Compliance and data boundaries

Three points when handing historical content and market data to an AI tool. First, de-identify: strip or hash user IDs, nicknames, and contact details. Second, data minimization: upload only the fields the analysis needs. Third, keep a trail: version-control the scripts and intermediate results so the work can be audited and reproduced. As data volume grows and intermediate artifacts need to be shared across collaborators, you can store them in an object storage service and pair that with a logging service plus monitoring alerts to record task execution, making the whole analysis chain observable and traceable.

Reusable checklist

• Own content detail exported and structured into a table
• Definitions of the four derived metrics fixed in writing
• External data uses public fields only, in line with site terms of use
• Median and quartiles used for all cross-topic comparisons
• Priority score weights documented and adjustable
• Agent runs inside a limited directory, raw data read-only
• Every analysis step scripted, intermediate results persisted to disk
• Conservation, sampling, and back-calculation checks all passed
• Report covers conclusions, evidence, schedule, and risks
• Sensitive fields de-identified, data sources traceable

Run this once and you get more than three candidate directions. You get decision infrastructure you can reuse: next round you swap in the data, rerun the scripts, and the basis for judgment refreshes itself. The internal back-and-forth loses the soil it grew in.